WIP alpine build

.circleci/config.yml

@@ -6,6 +6,36 @@ commands:
       - run:
           name: "Pull submodules"
           command: git submodule update --init
+  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-cmake:
+    steps:
+      - run:
+          name: "Install CMake"
+          command: |
+            wget https://github.com/Kitware/CMake/releases/download/v3.21.4/cmake-3.21.4-linux-x86_64.tar.gz
+            sudo tar --strip-components=1 -C /usr/local -xf cmake-3.21.4-linux-x86_64.tar.gz
   install-xtensa-toolchain:
     parameters:
       variant:
@@ -22,12 +52,12 @@ commands:
     steps:
       - restore_cache:
           keys:
-            - llvm-source-13-v1
+            - llvm-source-11-v2
       - run:
           name: "Fetch LLVM source"
           command: make llvm-source
       - save_cache:
-          key: llvm-source-13-v1
+          key: llvm-source-11-v2
           paths:
             - llvm-project/clang/lib/Headers
             - llvm-project/clang/include
@@ -53,6 +83,31 @@ commands:
           key: binaryen-linux-v1
           paths:
             - build/wasm-opt
+  build-binaryen-linux-stretch:
+    steps:
+      - restore_cache:
+          keys:
+            - binaryen-linux-stretch-v1
+      - run:
+          name: "Build Binaryen"
+          command: |
+            CC=$PWD/llvm-build/bin/clang make binaryen
+      - save_cache:
+          key: binaryen-linux-stretch-v1
+          paths:
+            - build/wasm-opt
+  build-wasi-libc:
+    steps:
+      - restore_cache:
+          keys:
+            - wasi-libc-sysroot-v4
+      - run:
+          name: "Build wasi-libc"
+          command: make wasi-libc
+      - save_cache:
+          key: wasi-libc-sysroot-v4
+          paths:
+            - lib/wasi-libc/sysroot
   test-linux:
     parameters:
       llvm:
@@ -99,6 +154,281 @@ commands:
             - ~/.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 --no-install-recommends \
+                libgnutls30 libssl1.0.2 \
+                qemu-system-arm \
+                qemu-user \
+                gcc-avr \
+                avr-libc \
+                ninja-build \
+                python3
+      - install-node
+      - install-chrome
+      - install-wasmtime
+      - install-cmake
+      - hack-ninja-jobs
+      - 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 (may only have headers right now)
+              rm -rf llvm-project
+              make llvm-source
+              # 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
+      - build-binaryen-linux-stretch
+      - run:
+          name: "Build TinyGo"
+          command: |
+            make ASSERT=1
+            echo 'export PATH=$(pwd)/build:$PATH' >> $BASH_ENV
+      - build-wasi-libc
+      - run:
+          name: "Test TinyGo"
+          command: make ASSERT=1 test
+          no_output_timeout: 20m
+          environment:
+            # Note: -p=2 limits parallelism to two jobs at a time, which is
+            # necessary to keep memory consumption down and avoid OOM (for a
+            # 2CPU/4GB executor).
+            GOFLAGS: -p=2
+      - save_cache:
+          key: go-cache-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_BUILD_NUM }}
+          paths:
+            - ~/.cache/go-build
+            - /go/pkg/mod
+      - run: make gen-device -j4
+      - run: make smoketest
+      - run: make tinygo-test
+      - run: make wasmtest
+  build-linux:
+    steps:
+      - run:
+          name: "Install apk dependencies"
+          command: |
+            apk add git openssh make g++ gcompat
+      - checkout
+      - run:
+          name: "Install Go"
+          command: |
+            wget https://dl.google.com/go/go1.17.3.linux-amd64.tar.gz
+            tar -C /usr/local -xzf go1.17.3.linux-amd64.tar.gz
+            ln -s /usr/local/go/bin/go /usr/local/bin/go
+      #- submodules
+      - restore_cache:
+          name: "Restore Go cache"
+          keys:
+            - go-cache-alpine-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_PREVIOUS_BUILD_NUM }}
+            - go-cache-alpine-v2-{{ checksum "go.mod" }}
+      - restore_cache:
+          name: "Restore llvm-source cache"
+          keys:
+            - llvm-source-11-alpine-v2-x0
+      - run:
+          name: "Fetch LLVM source"
+          command: make llvm-source
+      - save_cache:
+          name: "Save llvm-source cache"
+          key: llvm-source-11-alpine-v2-x0
+          paths:
+            - llvm-project
+            #- llvm-project/clang/lib/Headers
+            #- llvm-project/clang/include
+            #- llvm-project/lld/include
+            #- llvm-project/llvm/include
+      - restore_cache:
+          name: "Restore llvm-build cache"
+          keys:
+            - llvm-build-11-alpine-v1-noassert-x0
+      - run:
+          name: "Build LLVM"
+          command: |
+            if [ ! -f llvm-build/lib/liblldELF.a ]
+            then
+              # fetch LLVM source (may only have headers right now)
+              #rm -rf llvm-project
+              #make llvm-source
+              # install dependencies
+              apk add cmake samurai python3
+              # build!
+              SAMUFLAGS=-j3 make llvm-build
+              #find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
+            fi
+      - save_cache:
+          name: "Save llvm-build cache"
+          key: llvm-build-11-alpine-v1-noassert-x0
+          paths:
+            llvm-build
+      - 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
+      - persist_to_workspace:
+          root: /tmp
+          paths:
+            - tinygo.linux-amd64.tar.gz
+      - store_artifacts:
+          path: /tmp/tinygo.linux-amd64.tar.gz
+      - store_artifacts:
+          path: /tmp/tinygo_amd64.deb
+      - save_cache:
+          name: "Save Go cache"
+          key: go-cache-alpine-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_BUILD_NUM }}
+          paths:
+            - ~/.cache/go-build
+            - /go/pkg/mod
+  test-linux-build:
+    # Now run the smoke tests for the generated binary.
+    steps:
+      - attach_workspace:
+          at: /tmp/workspace
+      - checkout
+      - run:
+          name: "Install apt dependencies"
+          command: |
+            sudo apt-get update
+            sudo apt-get install --no-install-recommends \
+                gcc-avr \
+                avr-libc
+      - install-xtensa-toolchain:
+          variant: "linux-amd64"
+      - run:
+          name: "Extract release tarball"
+          command: |
+            mkdir -p ~/lib
+            tar -C ~/lib -xf /tmp/workspace/tinygo.linux-amd64.tar.gz
+            ln -s ~/lib/tinygo/bin/tinygo ~/go/bin/tinygo
+            tinygo version
+      - run: make smoketest
+  build-macos:
+    steps:
+      - checkout
+      - submodules
+      - run:
+          name: "Install dependencies"
+          command: |
+            curl https://dl.google.com/go/go1.17.darwin-amd64.tar.gz -o go1.17.darwin-amd64.tar.gz
+            sudo tar -C /usr/local -xzf go1.17.darwin-amd64.tar.gz
+            ln -s /usr/local/go/bin/go /usr/local/bin/go
+            HOMEBREW_NO_AUTO_UPDATE=1 brew install qemu cmake ninja
+      - install-xtensa-toolchain:
+          variant: "macos"
+      - restore_cache:
+          keys:
+            - go-cache-macos-v3-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_PREVIOUS_BUILD_NUM }}
+            - go-cache-macos-v3-{{ checksum "go.mod" }}
+      - restore_cache:
+          keys:
+            - llvm-source-11-macos-v3
+      - run:
+          name: "Fetch LLVM source"
+          command: make llvm-source
+      - save_cache:
+          key: llvm-source-11-macos-v3
+          paths:
+            - llvm-project/clang/lib/Headers
+            - llvm-project/clang/include
+            - llvm-project/lld/include
+            - llvm-project/llvm/include
+      - restore_cache:
+          keys:
+            - 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)
+              rm -rf llvm-project
+              make llvm-source
+              # build!
+              make llvm-build
+              find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
+            fi
+      - save_cache:
+          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
+      - run:
+          name: "Build wasi-libc"
+          command: make wasi-libc
+      - save_cache:
+          key: wasi-libc-sysroot-macos-v4
+          paths:
+            - lib/wasi-libc/sysroot
+      - run:
+          name: "Test TinyGo"
+          command: make test
+          no_output_timeout: 20m
+      - run:
+          name: "Build TinyGo release"
+          command: |
+            make release -j3
+            cp -p build/release.tar.gz /tmp/tinygo.darwin-amd64.tar.gz
+      - store_artifacts:
+          path: /tmp/tinygo.darwin-amd64.tar.gz
+      - run:
+          name: "Extract release tarball"
+          command: |
+            mkdir -p ~/lib
+            tar -C /usr/local/opt -xf /tmp/tinygo.darwin-amd64.tar.gz
+            ln -s /usr/local/opt/tinygo/bin/tinygo /usr/local/bin/tinygo
+            tinygo version
+      - run: make smoketest AVR=0
+      - save_cache:
+          key: go-cache-macos-v3-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_BUILD_NUM }}
+          paths:
+            - ~/.cache/go-build
+            - /go/pkg/mod
 
 jobs:
   test-llvm11-go115:
@@ -107,15 +437,43 @@ jobs:
     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.17-stretch
+    steps:
+      - assert-test-linux
+  build-linux:
+    docker:
+      - image: alpine:3.14
+    steps:
+      - build-linux
+  test-linux-build:
+    docker:
+      - image: cimg/go:1.17
+    steps:
+      - test-linux-build
+  build-macos:
+    macos:
+      xcode: "11.1.0" # macOS 10.14
+    steps:
+      - build-macos
+
+
 
 workflows:
   test-all:
     jobs:
-      - test-llvm11-go115
-      - test-llvm12-go116
+      #- test-llvm11-go115
+      #- test-llvm11-go116
+      - build-linux
+      - test-linux-build:
+          requires:
+            - build-linux
+      #- build-macos
+      #- assert-test-linux

.github/workflows/build-macos.yml

@@ -1,95 +0,0 @@
-name: macOS
-
-on:
-  pull_request:
-  push:
-    branches:
-      - dev
-      - release
-
-jobs:
-  build-macos:
-    name: build-macos
-    runs-on: macos-10.15
-    steps:
-      - name: Install Go
-        uses: actions/setup-go@v2
-        with:
-          go-version: '1.17'
-      - name: Install Dependencies
-        shell: bash
-        run: |
-          HOMEBREW_NO_AUTO_UPDATE=1 brew install qemu binaryen
-      - name: Install Xtensa toolchain
-        shell: bash
-        run: |
-          curl -L https://github.com/espressif/crosstool-NG/releases/download/esp-2020r2/xtensa-esp32-elf-gcc8_2_0-esp-2020r2-macos.tar.gz -o xtensa-esp32-elf-gcc8_2_0-esp-2020r2-macos.tar.gz
-          sudo tar -C /usr/local -xf xtensa-esp32-elf-gcc8_2_0-esp-2020r2-macos.tar.gz
-          sudo ln -s /usr/local/xtensa-esp32-elf/bin/xtensa-esp32-elf-ld /usr/local/bin/xtensa-esp32-elf-ld
-          rm xtensa-esp32-elf-gcc8_2_0-esp-2020r2-macos.tar.gz
-      - name: Checkout
-        uses: actions/checkout@v2
-        with:
-          submodules: true
-      - name: Cache LLVM source
-        uses: actions/cache@v2
-        id: cache-llvm-source
-        with:
-          key: llvm-source-13-macos-v1
-          path: |
-            llvm-project/clang/lib/Headers
-            llvm-project/clang/include
-            llvm-project/lld/include
-            llvm-project/llvm/include
-      - name: Download LLVM source
-        if: steps.cache-llvm-source.outputs.cache-hit != 'true'
-        run: make llvm-source
-      - name: Cache LLVM build
-        uses: actions/cache@v2
-        id: cache-llvm-build
-        with:
-          key: llvm-build-13-macos-v2
-          path: llvm-build
-      - name: Build LLVM
-        if: steps.cache-llvm-build.outputs.cache-hit != 'true'
-        shell: bash
-        run: |
-          # fetch LLVM source
-          rm -rf llvm-project
-          make llvm-source
-          # install dependencies
-          HOMEBREW_NO_AUTO_UPDATE=1 brew install cmake ninja
-          # build!
-          make llvm-build
-          find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
-      - name: Cache wasi-libc sysroot
-        uses: actions/cache@v2
-        id: cache-wasi-libc
-        with:
-          key: wasi-libc-sysroot-v1
-          path: lib/wasi-libc/sysroot
-      - name: Build wasi-libc
-        if: steps.cache-wasi-libc.outputs.cache-hit != 'true'
-        run: make wasi-libc
-      - name: Test TinyGo
-        shell: bash
-        run: make test GOTESTFLAGS="-v -short"
-      - name: Build TinyGo release tarball
-        run: make release -j3
-      - name: Make release artifact
-        shell: bash
-        run: cp -p build/release.tar.gz build/tinygo.darwin-amd64.tar.gz 
-      - name: Publish release artifact
-        # Note: this release artifact is double-zipped, see:
-        # https://github.com/actions/upload-artifact/issues/39
-        # We can essentially pick one of these:
-        # - have a double-zipped artifact when downloaded from the UI
-        # - have a very slow artifact upload
-        # We're doing the former here, to keep artifact uploads fast.
-        uses: actions/upload-artifact@v2
-        with:
-          name: release-double-zipped
-          path: build/tinygo.darwin-amd64.tar.gz
-      - name: Smoke tests
-        shell: bash
-        run: make smoketest TINYGO=$(PWD)/build/tinygo AVR=0

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

@@ -1,15 +1,11 @@
-# This is the Github action to build and push the tinygo/tinygo-dev Docker image.
-# If you are looking for the tinygo/tinygo "release" Docker image please see
-# https://github.com/tinygo-org/docker
-#
-name: Docker
+name: CI for tinygo-dev docker container
 on:
   push:
     branches: [ dev, fix-docker-llvm-build ]
 
 jobs:
   push_to_registry:
-    name: build-push-dev
+    name: Push Docker image to GHCR/Docker Hub
     runs-on: ubuntu-latest
     permissions:
       packages: write
@@ -19,8 +15,6 @@ jobs:
         uses: actions/checkout@v2
         with:
           submodules: recursive
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v1
       - name: Docker meta
         id: meta
         uses: docker/metadata-action@v3
@@ -49,11 +43,3 @@ jobs:
           push: true
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}
-          cache-from: type=gha
-          cache-to: type=gha,mode=max
-      - name: Trigger Drivers repo build on CircleCI
-        run: |
-          curl --location --request POST 'https://circleci.com/api/v2/project/github/tinygo-org/drivers/pipeline' \
-            --header 'Content-Type: application/json' \
-            -d '{"branch": "dev"}' \
-            -u "${{ secrets.CIRCLECI_API_TOKEN }}"

.github/workflows/linux.yml

@@ -1,241 +0,0 @@
-name: Linux
-
-on:
-  pull_request:
-  push:
-    branches:
-      - dev
-      - release
-
-jobs:
-  build-linux:
-    # Build Linux binaries, ready for release.
-    # This intentionally uses an older Linux image, so that we compile against
-    # an older glibc version and therefore are compatible with a wide range of
-    # Linux distributions.
-    runs-on: ubuntu-18.04
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-        with:
-          submodules: true
-      - name: Install apt dependencies
-        run: |
-          sudo apt-get install --no-install-recommends \
-              ninja-build
-      - name: Install Go
-        uses: actions/setup-go@v2
-        with:
-          go-version: '1.17'
-      - name: Cache Go
-        uses: actions/cache@v2
-        with:
-          key: go-cache-linux-v1-${{ hashFiles('go.mod') }}
-          path: |
-            ~/.cache/go-build
-            ~/go/pkg/mod
-      - name: Cache LLVM source
-        uses: actions/cache@v2
-        id: cache-llvm-source
-        with:
-          key: llvm-source-13-linux-v1
-          path: |
-            llvm-project/clang/lib/Headers
-            llvm-project/clang/include
-            llvm-project/lld/include
-            llvm-project/llvm/include
-      - name: Download LLVM source
-        if: steps.cache-llvm-source.outputs.cache-hit != 'true'
-        run: make llvm-source
-      - name: Cache LLVM build
-        uses: actions/cache@v2
-        id: cache-llvm-build
-        with:
-          key: llvm-build-13-linux-v1
-          path: llvm-build
-      - name: Build LLVM
-        if: steps.cache-llvm-build.outputs.cache-hit != 'true'
-        run: |
-          # fetch LLVM source
-          rm -rf llvm-project
-          make llvm-source
-          # build!
-          make llvm-build
-          # Remove unnecessary object files (to reduce cache size).
-          find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
-      - name: Cache Binaryen
-        uses: actions/cache@v2
-        id: cache-binaryen
-        with:
-          key: binaryen-linux-v1
-          path: build/wasm-opt
-      - name: Build Binaryen
-        if: steps.cache-binaryen.outputs.cache-hit != 'true'
-        run: make binaryen
-      - name: Cache wasi-libc
-        uses: actions/cache@v2
-        id: cache-wasi-libc
-        with:
-          key: wasi-libc-sysroot-linux-asserts-v2
-          path: lib/wasi-libc/sysroot
-      - name: Build wasi-libc
-        if: steps.cache-wasi-libc.outputs.cache-hit != 'true'
-        run: make wasi-libc
-      - name: Install fpm
-        run: |
-          sudo apt-get install ruby ruby-dev
-          sudo gem install --no-document fpm
-      - name: Build TinyGo release
-        run: |
-          make release deb -j3
-          cp -p build/release.tar.gz /tmp/tinygo.linux-amd64.tar.gz
-          cp -p build/release.deb    /tmp/tinygo_amd64.deb
-      - name: Publish release artifact
-        uses: actions/upload-artifact@v2
-        with:
-          name: release-double-zipped
-          path: |
-            /tmp/tinygo.linux-amd64.tar.gz
-            /tmp/tinygo_amd64.deb
-  test-linux-build:
-    # Test the binaries built in the build-linux job by running the smoke tests.
-    runs-on: ubuntu-latest
-    needs: build-linux
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-      - name: Install Go
-        uses: actions/setup-go@v2
-        with:
-          go-version: '1.17'
-      - name: Install wasmtime
-        run: |
-          curl https://wasmtime.dev/install.sh -sSf | bash
-          echo "$HOME/.wasmtime/bin" >> $GITHUB_PATH
-      - name: Download release artifact
-        uses: actions/download-artifact@v2
-        with:
-          name: release-double-zipped
-      - name: Extract release tarball
-        run: |
-          mkdir -p ~/lib
-          tar -C ~/lib -xf tinygo.linux-amd64.tar.gz
-          ln -s ~/lib/tinygo/bin/tinygo ~/go/bin/tinygo
-      - name: Install apt dependencies
-        run: |
-          sudo apt-get install --no-install-recommends \
-              gcc-avr \
-              avr-libc
-      - name: "Install Xtensa toolchain"
-        run: |
-          curl -L https://github.com/espressif/crosstool-NG/releases/download/esp-2020r2/xtensa-esp32-elf-gcc8_2_0-esp-2020r2-linux-amd64.tar.gz -o xtensa-esp32-elf-gcc8_2_0-esp-2020r2-linux-amd64.tar.gz
-          sudo tar -C /usr/local -xf xtensa-esp32-elf-gcc8_2_0-esp-2020r2-linux-amd64.tar.gz
-          sudo ln -s /usr/local/xtensa-esp32-elf/bin/xtensa-esp32-elf-ld /usr/local/bin/xtensa-esp32-elf-ld
-          rm xtensa-esp32-elf-gcc8_2_0-esp-2020r2-linux-amd64.tar.gz
-      - run: make tinygo-test-wasi-fast
-      - run: make smoketest
-  assert-test-linux:
-    # Run all tests that can run on Linux, with LLVM assertions enabled to catch
-    # potential bugs.
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-        with:
-          submodules: true
-      - name: Install apt dependencies
-        run: |
-          echo "Show cpuinfo; sometimes useful when troubleshooting"
-          cat /proc/cpuinfo
-          sudo apt-get update
-          sudo apt-get install --no-install-recommends \
-              qemu-system-arm \
-              qemu-system-riscv32 \
-              qemu-user \
-              gcc-avr \
-              avr-libc \
-              simavr \
-              ninja-build
-      - name: Install Go
-        uses: actions/setup-go@v2
-        with:
-          go-version: '1.17'
-      - name: Install Node.js
-        uses: actions/setup-node@v2
-        with:
-          node-version: '12'
-      - name: Install wasmtime
-        run: |
-          curl https://wasmtime.dev/install.sh -sSf | bash
-          echo "$HOME/.wasmtime/bin" >> $GITHUB_PATH
-      - name: Cache Go
-        uses: actions/cache@v2
-        with:
-          key: go-cache-linux-asserts-v1-${{ hashFiles('go.mod') }}
-          path: |
-            ~/.cache/go-build
-            ~/go/pkg/mod
-      - name: Cache LLVM source
-        uses: actions/cache@v2
-        id: cache-llvm-source
-        with:
-          key: llvm-source-13-linux-asserts-v1
-          path: |
-            llvm-project/clang/lib/Headers
-            llvm-project/clang/include
-            llvm-project/lld/include
-            llvm-project/llvm/include
-      - name: Download LLVM source
-        if: steps.cache-llvm-source.outputs.cache-hit != 'true'
-        run: make llvm-source
-      - name: Cache LLVM build
-        uses: actions/cache@v2
-        id: cache-llvm-build
-        with:
-          key: llvm-build-13-linux-asserts-v1
-          path: llvm-build
-      - name: Build LLVM
-        if: steps.cache-llvm-build.outputs.cache-hit != 'true'
-        run: |
-          # fetch LLVM source
-          rm -rf llvm-project
-          make llvm-source
-          # build!
-          make llvm-build ASSERT=1
-          # Remove unnecessary object files (to reduce cache size).
-          find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
-      - name: Cache Binaryen
-        uses: actions/cache@v2
-        id: cache-binaryen
-        with:
-          key: binaryen-linux-asserts-v1
-          path: build/wasm-opt
-      - name: Build Binaryen
-        if: steps.cache-binaryen.outputs.cache-hit != 'true'
-        run: make binaryen
-      - name: Cache wasi-libc
-        uses: actions/cache@v2
-        id: cache-wasi-libc
-        with:
-          key: wasi-libc-sysroot-linux-asserts-v2
-          path: lib/wasi-libc/sysroot
-      - name: Build wasi-libc
-        if: steps.cache-wasi-libc.outputs.cache-hit != 'true'
-        run: make wasi-libc
-      - run: make gen-device -j4
-      - name: Test TinyGo
-        run: make ASSERT=1 test
-      - name: Build TinyGo
-        run: |
-          make ASSERT=1
-          echo "$(pwd)/build" >> $GITHUB_PATH
-      - name: Test stdlib packages
-        run: make tinygo-test
-      - name: Install Xtensa toolchain
-        run: |
-          curl -L https://github.com/espressif/crosstool-NG/releases/download/esp-2020r2/xtensa-esp32-elf-gcc8_2_0-esp-2020r2-linux-amd64.tar.gz -o xtensa-esp32-elf-gcc8_2_0-esp-2020r2-linux-amd64.tar.gz
-          sudo tar -C /usr/local -xf xtensa-esp32-elf-gcc8_2_0-esp-2020r2-linux-amd64.tar.gz
-          sudo ln -s /usr/local/xtensa-esp32-elf/bin/xtensa-esp32-elf-ld /usr/local/bin/xtensa-esp32-elf-ld
-          rm xtensa-esp32-elf-gcc8_2_0-esp-2020r2-linux-amd64.tar.gz
-      - run: make smoketest
-      - run: make wasmtest

.github/workflows/windows.yml

@@ -1,7 +1,7 @@
 name: Windows
 
 on:
-  pull_request:
+  #pull_request:
   push:
     branches:
       - dev
@@ -15,27 +15,24 @@ jobs:
         uses: actions/setup-go@v2
         with:
           go-version: '1.17'
-      - uses: MinoruSekine/setup-scoop@v1
-      - name: Install Dependencies
+      - name: Install QEMU
         shell: bash
         run: |
-          scoop install ninja binaryen
+          choco install qemu --version=2020.06.12
+          echo "C:\Program Files\QEMU" >> $GITHUB_PATH
+      - 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-13-windows-v1
+          key: llvm-source-11-windows-v1
           path: |
             llvm-project/clang/lib/Headers
             llvm-project/clang/include
@@ -48,7 +45,7 @@ jobs:
         uses: actions/cache@v2
         id: cache-llvm-build
         with:
-          key: llvm-build-13-windows-v1
+          key: llvm-build-11-windows-v2
           path: llvm-build
       - name: Build LLVM
         if: steps.cache-llvm-build.outputs.cache-hit != 'true'
@@ -70,9 +67,18 @@ jobs:
       - 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-v1
+          path: build/binaryen
+      - 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"
+        run: make test
       - name: Build TinyGo release tarball
         run: make build/release -j4
       - name: Make release artifact
@@ -92,6 +98,6 @@ jobs:
           path: build/release/release.zip
       - name: Smoke tests
         shell: bash
-        run: make smoketest TINYGO=$(PWD)/build/tinygo AVR=0 XTENSA=0
+        run: make smoketest TINYGO=build/tinygo AVR=0 XTENSA=0
       - name: Test stdlib packages
         run: make tinygo-test

.gitignore

@@ -20,12 +20,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

BUILDING.md

@@ -11,7 +11,12 @@ lld so that the binary can be easily moved between systems. It also shows how to
 build a release tarball that includes this binary and all necessary extra files.
 
 **Note**: this documentation describes how to build a statically linked release
-tarball. If you want to help with development of TinyGo itself, you should follow the guide located at https://tinygo.org/docs/guides/build/
+tarball. If you want to develop TinyGo, you will probably want to follow a
+different guide:
+
+  * [Linux](https://tinygo.org/getting-started/linux/#source-install)
+  * [macOS](https://tinygo.org/getting-started/macos/#source-install)
+  * [Windows](https://tinygo.org/getting-started/windows/#source-install)
 
 ## Dependencies
 

CHANGELOG.md

@@ -1,202 +1,3 @@
-0.22.0
----
-
-* **command line**
-  - add asyncify to scheduler flag help
-  - support -run for tests
-  - remove FreeBSD target support
-  - add LLVM 12 and LLVM 13 support, use LLVM 13 by default
-  - add support for ARM64 MacOS
-  - improve help
-  - check /run/media as well as /media on Linux for non-debian-based distros
-  - `test`: set cmd.Dir even when running emulators
-  - `info`: add JSON output using the `-json` flag
-* **compiler**
-  - `builder`: fix off-by-one in size calculation
-  - `builder`: handle concurrent library header rename
-  - `builder`: use flock to avoid double-compiles
-  - `builder`: use build ID as cache key
-  - `builder`: add -fno-stack-protector to musl build
-  - `builder`: update clang header search path to look in /usr/lib
-  - `builder`: explicitly disable unwind tables for ARM
-  - `cgo`: add support for `C.CString` and related functions
-  - `compiler`: fix ranging over maps with particular map types
-  - `compiler`: add correct debug location to init instructions
-  - `compiler`: fix emission of large object layouts
-  - `compiler`: work around AVR atomics bugs
-  - `compiler`: predeclare runtime.trackPointer
-  - `interp`: work around AVR function pointers in globals
-  - `interp`: run goroutine starts and checks at runtime
-  - `interp`: always run atomic and volatile loads/stores at runtime
-  - `interp`: bump timeout to 180 seconds
-  - `interp`: handle type assertions on nil interfaces
-  - `loader`: elminate goroot cache inconsistency
-  - `loader`: respect $GOROOT when running `go list`
-  - `transform`: allocate the correct amount of bytes in an alloca
-  - `transform`: remove switched func lowering
-* **standard library**
-  - `crypto/rand`: show error if platform has no rng
-  - `device/*`: add `*_Msk` field for each bit field and avoid duplicates
-  - `device/*`: provide Set/Get for each register field described in the SVD files
-  - `internal/task`: swap stack chain when switching goroutines
-  - `internal/task`: remove `-scheduler=coroutines`
-  - `machine`: add `Device` string constant
-  - `net`: add bare Interface implementation
-  - `net`: add net.Buffers
-  - `os`: stub out support for some features
-  - `os`: obey TMPDIR on unix, TMP on Windows, etc
-  - `os`: implement `ReadAt`, `Mkdir`, `Remove`, `Stat`, `Lstat`, `CreateTemp`, `MkdirAll`, `Chdir`, `Chmod`, `Clearenv`, `Unsetenv`, `Setenv`, `MkdirTemp`, `Rename`, `Seek`, `ExpandEnv`, `Symlink`, `Readlink`
-  - `os`: implement `File.Stat`
-  - `os`: fix `IsNotExist` on nonexistent path
-  - `os`: fix opening files on WASI in read-only mode
-  - `os`: work around lack of `syscall.seek` on 386 and arm
-  - `reflect`: make sure indirect pointers are handled correctly
-  - `runtime`: allow comparing interfaces
-  - `runtime`: use LLVM intrinsic to read the stack pointer
-  - `runtime`: strengthen hashmap hash function for structs and arrays
-  - `runtime`: fix float/complex hashing
-  - `runtime`: fix nil map dereference
-  - `runtime`: add realloc implementation to GCs
-  - `runtime`: handle negative sleep times
-  - `runtime`: correct GC scan bounds
-  - `runtime`: remove extalloc GC
-  - `rumtime`: implement `__sync` libcalls as critical sections for most microcontrollers
-  - `runtime`: add stubs for `Func.FileLine` and `Frame.PC`
-  - `sync`: fix concurrent read-lock on write-locked RWMutex
-  - `sync`: add a package doc
-  - `sync`: add tests
-  - `syscall`: add support for `Mmap` and `Mprotect`
-  - `syscall`: fix array size for mmap slice creation
-  - `syscall`: enable `Getwd` in wasi
-  - `testing`: add a stub for `CoverMode`
-  - `testing`: support -bench option to run benchmarks matching the given pattern.
-  - `testing`: support b.SetBytes(); implement sub-benchmarks.
-  - `testing`: replace spaces with underscores in test/benchmark names, as upstream does
-  - `testing`: implement testing.Cleanup
-  - `testing`: allow filtering subbenchmarks with the `-bench` flag
-  - `testing`: implement `-benchtime` flag
-  - `testing`: print duration
-  - `testing`: allow filtering of subtests using `-run`
-* **targets**
-  - `all`: change LLVM features to match vanilla Clang
-  - `avr`: use interrupt-based timer which is much more accurate
-  - `nrf`: fix races in I2C
-  - `samd51`: implement TRNG for randomness
-  - `stm32`: pull-up on I2C lines
-  - `stm32`: fix timeout for i2c comms
-  - `stm32f4`, `stm32f103`: initial implementation for ADC
-  - `stm32f4`, `stm32f7`, `stm32l0x2`, `stm32l4`, `stm32l5`, `stm32wl`: TRNG implementation in crypto/rand
-  - `stm32wl`: add I2C support
-  - `windows`: add support for the `-size=` flag
-  - `wasm`: add support for `tinygo test`
-  - `wasi`, `wasm`: raise default stack size to 16 KiB
-* **boards**
-  - add M5Stack
-  - add lorae5 (stm32wle) support
-  - add Generic Node Sensor Edition
-  - add STM32F469 Discovery
-  - add M5Stamp C3
-  - add Blues Wireless Swan
-  - `bluepill`: add definitions for ADC pins
-  - `stm32f4disco`: add definitions for ADC pins
-  - `stm32l552ze`: use supported stlink interface
-  - `microbit-v2`: add some pin definitions
-
-
-0.21.0
----
-
-* **command line**
-  - drop support for LLVM 10
-  - `build`: drop support for LLVM targets in the -target flag
-  - `build`: fix paths in error messages on Windows
-  - `build`: add -p flag to set parallelism
-  - `lldb`: implement `tinygo lldb` subcommand
-  - `test`: use emulator exit code instead of parsing test output
-  - `test`: pass testing arguments to wasmtime
-* **compiler**
-  - use -opt flag for optimization level in CFlags (-Os, etc)
-  - `builder`: improve accuracy of the -size=full flag
-  - `builder`: hardcode some more frame sizes for __aeabi_* functions
-  - `builder`: add support for -size= flag for WebAssembly
-  - `cgo`: fix line/column reporting in syntax error messages
-  - `cgo`: support function definitions in CGo headers
-  - `cgo`: implement rudimentary C array decaying
-  - `cgo`: add support for stdio in picolibc and wasi-libc
-  - `cgo`: run CGo parser per file, not per CGo fragment
-  - `compiler`: fix unintentionally exported math functions
-  - `compiler`: properly implement div and rem operations
-  - `compiler`: add support for recursive function types
-  - `compiler`: add support for the `go` keyword on interface methods
-  - `compiler`: add minsize attribute for -Oz
-  - `compiler`: add "target-cpu" and "target-features" attributes
-  - `compiler`: fix indices into strings and arrays
-  - `compiler`: fix string compare functions
-  - `interp`: simplify some code to avoid some errors
-  - `interp`: support recursive globals (like linked lists) in globals
-  - `interp`: support constant globals
-  - `interp`: fix reverting of extractvalue/insertvalue with multiple indices
-  - `transform`: work around renamed return type after merging LLVM modules
-* **standard library**
-  - `internal/bytealg`: fix indexing error in Compare()
-  - `machine`: support Pin.Get() function when the pin is configured as output
-  - `net`, `syscall`: Reduce code duplication by switching to internal/itoa.
-  - `os`: don't try to read executable path on baremetal
-  - `os`: implement Getwd
-  - `os`: add File.WriteString and File.WriteAt
-  - `reflect`: fix type.Size() to account for struct padding
-  - `reflect`: don't construct an interface-in-interface value
-  - `reflect`: implement Value.Elem() for interface values
-  - `reflect`: fix Value.Index() in a specific case
-  - `reflect`: add support for DeepEqual
-  - `runtime`: add another set of invalid unicode runes to encodeUTF8()
-  - `runtime`: only initialize os.runtime_args when needed
-  - `runtime`: only use CRLF on baremetal systems for println
-  - `runtime/debug`: stub `debug.SetMaxStack`
-  - `runtime/debug`: stub `debug.Stack`
-  - `testing`: add a stub for t.Parallel()
-  - `testing`: add support for -test.short flag
-  - `testing`: stub B.ReportAllocs()
-  - `testing`: add `testing.Verbose`
-  - `testing`: stub `testing.AllocsPerRun`
-* **targets**
-  - fix gen-device-svd to handle 64-bit values
-  - add CPU and Features property to all targets
-  - match LLVM triple to the one Clang uses
-  - `atsam`: simplify definition of SERCOM UART, I2C and SPI peripherals
-  - `atsam`: move I2S0 to machine file
-  - `esp32`: fix SPI configuration
-  - `esp32c3`: add support for GDB debugging
-  - `esp32c3`: add support for CPU interrupts
-  - `esp32c3`: use tasks scheduler by default
-  - `fe310`: increase CPU frequency from 16MHz to 320MHz
-  - `fe310`: add support for bit banging drivers
-  - `linux`: build static binaries using musl
-  - `linux`: reduce binary size by calling `write` instead of `putchar`
-  - `linux`: add support for GOARM
-  - `riscv`: implement 32-bit atomic operations
-  - `riscv`: align the heap to 16 bytes
-  - `riscv`: switch to tasks-based scheduler
-  - `rp2040`: add CPUFrequency()
-  - `rp2040`: improve I2C baud rate configuration
-  - `rp2040`: add pin interrupt API
-  - `rp2040`: refactor PWM code and fix Period calculation
-  - `stm32f103`: fix SPI
-  - `stm32f103`: make SPI frequency selection more flexible
-  - `qemu`: signal correct exit code to QEMU
-  - `wasi`: run C/C++ constructors at startup
-  - `wasm`: ensure heapptr is aligned
-  - `wasm`: update wasi-libc dependency
-  - `wasm`: wasi: use asyncify
-  - `wasm`: support `-scheduler=none`
-  - `windows`: add support for Windows (amd64 only for now)
-* **boards**
-  - `feather-stm32f405`, `feather-rp2040`: add I2C pin names
-  - `m5stack-core2`: add M5Stack Core2
-  - `nano-33-ble`: SoftDevice s140v7 support
-  - `nano-33-ble`: add constants for more on-board pins
-
-
 0.20.0
 ---
 

CONTRIBUTING.md

@@ -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
+```

Dockerfile

@@ -1,50 +1,80 @@
-# tinygo-llvm stage obtains the llvm source for TinyGo
-FROM golang:1.17 AS tinygo-llvm
+# TinyGo base stage installs the most recent Go 1.17.x, LLVM 11 and the TinyGo compiler itself.
+FROM golang:1.17 AS tinygo-base
 
-RUN apt-get update && \
-    apt-get install -y apt-utils make cmake clang-11 binutils-avr gcc-avr avr-libc ninja-build
-
-COPY ./Makefile /tinygo/Makefile
-
-RUN cd /tinygo/ && \
-    make llvm-source
-
-# tinygo-llvm-build stage build the custom llvm with xtensa support
-FROM tinygo-llvm AS tinygo-llvm-build
-
-RUN cd /tinygo/ && \
-    make llvm-build
-
-# tinygo-xtensa stage installs tools needed for ESP32
-FROM tinygo-llvm-build AS tinygo-xtensa
-
-ARG xtensa_version="1.22.0-80-g6c4433a-5.2.0"
-RUN cd /tmp/ && \
-    wget -q https://dl.espressif.com/dl/xtensa-esp32-elf-linux64-${xtensa_version}.tar.gz && \
-    tar xzf xtensa-esp32-elf-linux64-${xtensa_version}.tar.gz && \
-    cp ./xtensa-esp32-elf/bin/xtensa-esp32-elf-ld /usr/local/bin/ && \
-    rm -rf /tmp/xtensa*
-
-# tinygo-compiler stage builds the compiler itself
-FROM tinygo-xtensa AS tinygo-compiler
+RUN wget -O- https://apt.llvm.org/llvm-snapshot.gpg.key| apt-key add - && \
+    echo "deb http://apt.llvm.org/bullseye/ llvm-toolchain-bullseye-11 main" >> /etc/apt/sources.list && \
+    apt-get update && \
+    apt-get install -y llvm-11-dev libclang-11-dev lld-11 git
 
 COPY . /tinygo
 
-# update submodules
+# remove submodules directories and re-init them to fix any hard-coded paths
+# after copying the tinygo directory in the previous step.
 RUN cd /tinygo/ && \
-    rm -rf ./lib/*/ && \
+    rm -rf ./lib/* && \
     git submodule sync && \
     git submodule update --init --recursive --force
 
-RUN cd /tinygo/ && \
-    make
-
-# tinygo-tools stage installs the needed dependencies to compile TinyGo programs for all platforms.
-FROM tinygo-compiler AS tinygo-tools
+COPY ./lib/picolibc-stdio.c /tinygo/lib/picolibc-stdio.c
 
 RUN cd /tinygo/ && \
-    make wasi-libc binaryen && \
-    make gen-device -j4 && \
-    cp build/* $GOPATH/bin/
+    go install /tinygo/
+
+# tinygo-wasm stage installs the needed dependencies to compile TinyGo programs for WASM.
+FROM tinygo-base AS tinygo-wasm
+
+COPY --from=tinygo-base /go/bin/tinygo /go/bin/tinygo
+COPY --from=tinygo-base /tinygo/src /tinygo/src
+COPY --from=tinygo-base /tinygo/targets /tinygo/targets
+
+RUN cd /tinygo/ && \
+    apt-get update && \
+    apt-get install -y make clang-11 libllvm11 lld-11 cmake ninja-build && \
+    mkdir build && \
+    make wasi-libc binaryen
+
+# tinygo-avr stage installs the needed dependencies to compile TinyGo programs for AVR microcontrollers.
+FROM tinygo-base AS tinygo-avr
+
+COPY --from=tinygo-base /go/bin/tinygo /go/bin/tinygo
+COPY --from=tinygo-base /tinygo/src /tinygo/src
+COPY --from=tinygo-base /tinygo/targets /tinygo/targets
+COPY --from=tinygo-base /tinygo/Makefile /tinygo/
+COPY --from=tinygo-base /tinygo/tools /tinygo/tools
+COPY --from=tinygo-base /tinygo/lib /tinygo/lib
+
+RUN cd /tinygo/ && \
+    apt-get update && \
+    apt-get install -y apt-utils make binutils-avr gcc-avr avr-libc && \
+    make gen-device-avr && \
+    apt-get autoremove -y && \
+    apt-get clean
+
+# tinygo-arm stage installs the needed dependencies to compile TinyGo programs for ARM microcontrollers.
+FROM tinygo-base AS tinygo-arm
+
+COPY --from=tinygo-base /go/bin/tinygo /go/bin/tinygo
+COPY --from=tinygo-base /tinygo/src /tinygo/src
+COPY --from=tinygo-base /tinygo/targets /tinygo/targets
+COPY --from=tinygo-base /tinygo/Makefile /tinygo/
+COPY --from=tinygo-base /tinygo/tools /tinygo/tools
+COPY --from=tinygo-base /tinygo/lib /tinygo/lib
+
+RUN cd /tinygo/ && \
+    apt-get update && \
+    apt-get install -y apt-utils make clang-11 && \
+    make gen-device-nrf && make gen-device-stm32
+
+# tinygo-all stage installs the needed dependencies to compile TinyGo programs for all platforms.
+FROM tinygo-wasm AS tinygo-all
+
+COPY --from=tinygo-base /tinygo/Makefile /tinygo/
+COPY --from=tinygo-base /tinygo/tools /tinygo/tools
+COPY --from=tinygo-base /tinygo/lib /tinygo/lib
+
+RUN cd /tinygo/ && \
+    apt-get update && \
+    apt-get install -y apt-utils make clang-11 binutils-avr gcc-avr avr-libc && \
+    make gen-device
 
 CMD ["tinygo"]

LICENSE

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

Makefile

@@ -9,34 +9,20 @@ CLANG_SRC ?= $(LLVM_PROJECTDIR)/clang
 LLD_SRC ?= $(LLVM_PROJECTDIR)/lld
 
 # Try to autodetect LLVM build tools.
-# Versions are listed here in descending priority order.
-LLVM_VERSIONS = 13 12 11
-errifempty = $(if $(1),$(1),$(error $(2)))
-detect = $(shell which $(call errifempty,$(firstword $(foreach p,$(2),$(shell command -v $(p) 2> /dev/null && echo $(p)))),failed to locate $(1) at any of: $(2)))
-toolSearchPathsVersion = $(1)-$(2)
-ifeq ($(shell uname -s),Darwin)
-	# Also explicitly search Brew's copy, which is not in PATH by default.
-	BREW_PREFIX := $(shell brew --prefix)
-	toolSearchPathsVersion += $(BREW_PREFIX)/opt/llvm@$(2)/bin/$(1)-$(2) $(BREW_PREFIX)/opt/llvm@$(2)/bin/$(1)
-endif
-# First search for a custom built copy, then move on to explicitly version-tagged binaries, then just see if the tool is in path with its normal name.
-findLLVMTool = $(call detect,$(1),$(abspath llvm-build/bin/$(1)) $(foreach ver,$(LLVM_VERSIONS),$(call toolSearchPathsVersion,$(1),$(ver))) $(1))
-CLANG ?= $(call findLLVMTool,clang)
-LLVM_AR ?= $(call findLLVMTool,llvm-ar)
-LLVM_NM ?= $(call findLLVMTool,llvm-nm)
+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))
 
 # Go binary and GOROOT to select
 GO ?= go
 export GOROOT = $(shell $(GO) env GOROOT)
 
-# Flags to pass to go test.
-GOTESTFLAGS ?= -v
-
 # md5sum binary
 MD5SUM = md5sum
 
 # tinygo binary for tests
-TINYGO ?= $(call detect,tinygo,tinygo $(CURDIR)/build/tinygo)
+TINYGO ?= $(word 1,$(call detect,tinygo)$(call detect,build/tinygo))
 
 # Use CCACHE for LLVM if possible
 ifneq (, $(shell command -v ccache 2> /dev/null))
@@ -68,18 +54,20 @@ ifeq ($(OS),Windows_NT)
     CGO_LDFLAGS += -static -static-libgcc -static-libstdc++
     CGO_LDFLAGS_EXTRA += -lversion
 
-    USE_SYSTEM_BINARYEN ?= 1
+    BINARYEN_OPTION += -DCMAKE_EXE_LINKER_FLAGS='-static-libgcc -static-libstdc++'
+
+    LIBCLANG_NAME = libclang
 
 else ifeq ($(shell uname -s),Darwin)
     MD5SUM = md5
-
-    USE_SYSTEM_BINARYEN ?= 1
-
+    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
@@ -95,24 +83,22 @@ 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
 
@@ -173,7 +159,7 @@ gen-device-rp: build/gen-device-svd
 
 # Get LLVM sources.
 $(LLVM_PROJECTDIR)/llvm:
-	git clone -b xtensa_release_13.0.0 --depth=1 https://github.com/tinygo-org/llvm-project $(LLVM_PROJECTDIR)
+	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.
@@ -182,18 +168,15 @@ $(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)
 
 # Build LLVM.
-$(LLVM_BUILDDIR): $(LLVM_BUILDDIR)/build.ninja
-	cd $(LLVM_BUILDDIR) && ninja $(NINJA_BUILD_TARGETS)
+$(LLVM_BUILDDIR): #$(LLVM_BUILDDIR)/build.ninja
+	cd $(LLVM_BUILDDIR) && ninja llvm-nm #$(NINJA_BUILD_TARGETS)
 
-ifneq ($(USE_SYSTEM_BINARYEN),1)
 # Build Binaryen
 .PHONY: binaryen
-binaryen: build/wasm-opt$(EXE)
-build/wasm-opt$(EXE):
-	mkdir -p build
-	cd lib/binaryen && cmake -G Ninja . -DBUILD_STATIC_LIB=ON $(BINARYEN_OPTION) && ninja bin/wasm-opt$(EXE)
-	cp lib/binaryen/bin/wasm-opt$(EXE) build/wasm-opt$(EXE)
-endif
+binaryen: build/wasm-opt
+build/wasm-opt:
+	cd lib/binaryen && cmake -G Ninja . -DBUILD_STATIC_LIB=ON $(BINARYEN_OPTION) && ninja
+	cp lib/binaryen/bin/wasm-opt build/wasm-opt
 
 # Build wasi-libc sysroot
 .PHONY: wasi-libc
@@ -209,50 +192,35 @@ 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 -timeout=20m -buildmode exe -tags byollvm ./builder ./cgo ./compileopts ./compiler ./interp ./transform .
 
-# Tests that take over a minute in wasi
-TEST_PACKAGES_SLOW = \
+TEST_PACKAGES = \
 	compress/bzip2 \
-	compress/flate \
-	crypto/dsa \
-	index/suffixarray \
-
-TEST_PACKAGES_BASE = \
-	compress/zlib \
 	container/heap \
 	container/list \
 	container/ring \
 	crypto/des \
-	crypto/elliptic/internal/fiat \
-	crypto/internal/subtle \
+	crypto/dsa \
 	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 \
+	hash/crc64 \
 	html \
+	index/suffixarray \
 	internal/itoa \
-	internal/profile \
 	math \
 	math/cmplx \
-	net/http/internal/ascii \
 	net/mail \
-	os \
-	path \
 	reflect \
-	sync \
 	testing \
 	testing/iotest \
 	text/scanner \
@@ -260,55 +228,15 @@ TEST_PACKAGES_BASE = \
 	unicode/utf16 \
 	unicode/utf8 \
 
-# Standard library packages that pass tests natively
-TEST_PACKAGES := \
-	$(TEST_PACKAGES_BASE)
-
-# archive/zip requires ReadAt, which is not yet supported on windows
-ifneq ($(OS),Windows_NT)
-TEST_PACKAGES := \
-	$(TEST_PACKAGES) \
-	archive/zip
-endif
-
-# Standard library packages that pass tests on wasi
-TEST_PACKAGES_WASI = \
-	$(TEST_PACKAGES_BASE)
-
 # Test known-working standard library packages.
 # TODO: parallelize, and only show failing tests (no implied -v flag).
 .PHONY: tinygo-test
 tinygo-test:
-	$(TINYGO) test $(TEST_PACKAGES) $(TEST_PACKAGES_SLOW)
-tinygo-test-fast:
 	$(TINYGO) test $(TEST_PACKAGES)
-tinygo-bench:
-	$(TINYGO) test -bench . $(TEST_PACKAGES) $(TEST_PACKAGES_SLOW)
-tinygo-bench-fast:
-	$(TINYGO) test -bench . $(TEST_PACKAGES)
-tinygo-test-wasi:
-	$(TINYGO) test -target wasi $(TEST_PACKAGES_WASI) $(TEST_PACKAGES_SLOW)
-tinygo-test-wasi-fast:
-	$(TINYGO) test -target wasi $(TEST_PACKAGES_WASI)
-tinygo-bench-wasi:
-	$(TINYGO) test -target wasi -bench . $(TEST_PACKAGES_WASI) $(TEST_PACKAGES_SLOW)
-tinygo-bench-wasi-fast:
-	$(TINYGO) test -target wasi -bench . $(TEST_PACKAGES_WASI)
-
-# Test external packages in a large corpus.
-test-corpus:
-	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) test $(GOTESTFLAGS) -timeout=1h -buildmode exe -tags byollvm -run TestCorpus . -corpus=testdata/corpus.yaml
-test-corpus-fast:
-	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) test $(GOTESTFLAGS) -timeout=1h -buildmode exe -tags byollvm -run TestCorpus -short . -corpus=testdata/corpus.yaml
-test-corpus-wasi: wasi-libc
-	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) test $(GOTESTFLAGS) -timeout=1h -buildmode exe -tags byollvm -run TestCorpus . -corpus=testdata/corpus.yaml -target=wasi
-
 
 .PHONY: smoketest
 smoketest:
 	$(TINYGO) version
-	# regression test for #2563
-	cd tests/os/smoke && $(TINYGO) test -c -target=pybadge && rm smoke.test
 	# test all examples (except pwm)
 	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/blinky1
 	@$(MD5SUM) test.hex
@@ -341,7 +269,6 @@ smoketest:
 	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/test
 	@$(MD5SUM) test.hex
 	# test simulated boards on play.tinygo.org
-ifneq ($(WASM), 0)
 	$(TINYGO) build -size short -o test.wasm -tags=arduino              examples/blinky1
 	@$(MD5SUM) test.wasm
 	$(TINYGO) build -size short -o test.wasm -tags=hifive1b             examples/blinky1
@@ -354,7 +281,6 @@ ifneq ($(WASM), 0)
 	@$(MD5SUM) test.wasm
 	$(TINYGO) build -size short -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
@@ -492,8 +418,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
@@ -502,12 +426,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=stm32f469disco      examples/blinky1
-	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=lorae5              examples/blinky1
-	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=swan                examples/blinky1
-	@$(MD5SUM) test.hex
 endif
 ifneq ($(AVR), 0)
 	$(TINYGO) build -size short -o test.hex -target=atmega1284p         examples/serial
@@ -536,23 +454,17 @@ ifneq ($(XTENSA), 0)
 	@$(MD5SUM) test.bin
 	$(TINYGO) build -size short -o test.bin -target m5stack-core2       examples/serial
 	@$(MD5SUM) test.bin
-	$(TINYGO) build -size short -o test.bin -target m5stack             examples/serial
-	@$(MD5SUM) test.bin
 endif
 	$(TINYGO) build -size short -o test.bin -target=esp32c3           	examples/serial
 	@$(MD5SUM) test.bin
-	$(TINYGO) build -size short -o test.bin -target=m5stamp-c3          examples/serial
-	@$(MD5SUM) test.bin
 	$(TINYGO) build -size short -o test.hex -target=hifive1b            examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=hifive1-qemu        examples/serial
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=maixbit             examples/blinky1
 	@$(MD5SUM) test.hex
-ifneq ($(WASM), 0)
 	$(TINYGO) build -size short -o wasm.wasm -target=wasm               examples/wasm/export
 	$(TINYGO) build -size short -o wasm.wasm -target=wasm               examples/wasm/main
-endif
 	# test various compiler flags
 	$(TINYGO) build -size short -o test.hex -target=pca10040 -gc=none -scheduler=none examples/blinky1
 	@$(MD5SUM) test.hex
@@ -565,7 +477,7 @@ endif
 	$(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
+	GOOS=windows GOARCH=amd64 $(TINYGO) build         -o test.exe       ./testdata/cgo
 ifneq ($(OS),Windows_NT)
 	# TODO: this does not yet work on Windows. Somehow, unused functions are
 	# not garbage collected.
@@ -576,7 +488,7 @@ endif
 wasmtest:
 	$(GO) test ./tests/wasm
 
-build/release: tinygo gen-device wasi-libc $(if $(filter 1,$(USE_SYSTEM_BINARYEN)),,binaryen)
+build/release: tinygo gen-device wasi-libc binaryen
 	@mkdir -p build/release/tinygo/bin
 	@mkdir -p build/release/tinygo/lib/clang/include
 	@mkdir -p build/release/tinygo/lib/CMSIS/CMSIS
@@ -590,14 +502,12 @@ build/release: tinygo gen-device wasi-libc $(if $(filter 1,$(USE_SYSTEM_BINARYEN
 	@mkdir -p build/release/tinygo/lib/picolibc/newlib/libc
 	@mkdir -p build/release/tinygo/lib/picolibc/newlib/libm
 	@mkdir -p build/release/tinygo/lib/wasi-libc
-	@mkdir -p build/release/tinygo/pkg/thumbv6m-unknown-unknown-eabi-cortex-m0
-	@mkdir -p build/release/tinygo/pkg/thumbv6m-unknown-unknown-eabi-cortex-m0plus
-	@mkdir -p build/release/tinygo/pkg/thumbv7em-unknown-unknown-eabi-cortex-m4
+	@mkdir -p build/release/tinygo/pkg/armv6m-unknown-unknown-eabi
+	@mkdir -p build/release/tinygo/pkg/armv7m-unknown-unknown-eabi
+	@mkdir -p build/release/tinygo/pkg/armv7em-unknown-unknown-eabi
 	@echo copying source files
 	@cp -p  build/tinygo$(EXE)           build/release/tinygo/bin
-ifneq ($(USE_SYSTEM_BINARYEN),1)
 	@cp -p  build/wasm-opt$(EXE)         build/release/tinygo/bin
-endif
 	@cp -p $(abspath $(CLANG_SRC))/lib/Headers/*.h build/release/tinygo/lib/clang/include
 	@cp -rp lib/CMSIS/CMSIS/Include      build/release/tinygo/lib/CMSIS/CMSIS
 	@cp -rp lib/CMSIS/README.md          build/release/tinygo/lib/CMSIS
@@ -641,12 +551,12 @@ endif
 	@cp -rp lib/wasi-libc/sysroot        build/release/tinygo/lib/wasi-libc/sysroot
 	@cp -rp src                          build/release/tinygo/src
 	@cp -rp targets                      build/release/tinygo/targets
-	./build/tinygo build-library -target=cortex-m0     -o build/release/tinygo/pkg/thumbv6m-unknown-unknown-eabi-cortex-m0/compiler-rt     compiler-rt
-	./build/tinygo build-library -target=cortex-m0plus -o build/release/tinygo/pkg/thumbv6m-unknown-unknown-eabi-cortex-m0plus/compiler-rt compiler-rt
-	./build/tinygo build-library -target=cortex-m4     -o build/release/tinygo/pkg/thumbv7em-unknown-unknown-eabi-cortex-m4/compiler-rt    compiler-rt
-	./build/tinygo build-library -target=cortex-m0     -o build/release/tinygo/pkg/thumbv6m-unknown-unknown-eabi-cortex-m0/picolibc     picolibc
-	./build/tinygo build-library -target=cortex-m0plus -o build/release/tinygo/pkg/thumbv6m-unknown-unknown-eabi-cortex-m0plus/picolibc picolibc
-	./build/tinygo build-library -target=cortex-m4     -o build/release/tinygo/pkg/thumbv7em-unknown-unknown-eabi-cortex-m4/picolibc    picolibc
+	./build/tinygo build-library -target=armv6m-unknown-unknown-eabi  -o build/release/tinygo/pkg/armv6m-unknown-unknown-eabi/compiler-rt compiler-rt
+	./build/tinygo build-library -target=armv7m-unknown-unknown-eabi  -o build/release/tinygo/pkg/armv7m-unknown-unknown-eabi/compiler-rt compiler-rt
+	./build/tinygo build-library -target=armv7em-unknown-unknown-eabi -o build/release/tinygo/pkg/armv7em-unknown-unknown-eabi/compiler-rt compiler-rt
+	./build/tinygo build-library -target=armv6m-unknown-unknown-eabi  -o build/release/tinygo/pkg/armv6m-unknown-unknown-eabi/picolibc picolibc
+	./build/tinygo build-library -target=armv7m-unknown-unknown-eabi  -o build/release/tinygo/pkg/armv7m-unknown-unknown-eabi/picolibc picolibc
+	./build/tinygo build-library -target=armv7em-unknown-unknown-eabi -o build/release/tinygo/pkg/armv7em-unknown-unknown-eabi/picolibc picolibc
 
 release: build/release
 	tar -czf build/release.tar.gz -C build/release tinygo

README.md

@@ -1,6 +1,6 @@
 # TinyGo - Go compiler for small places
 
-[![Linux](https://github.com/tinygo-org/tinygo/actions/workflows/linux.yml/badge.svg?branch=dev)](https://github.com/tinygo-org/tinygo/actions/workflows/linux.yml) [![macOS](https://github.com/tinygo-org/tinygo/actions/workflows/build-macos.yml/badge.svg?branch=dev)](https://github.com/tinygo-org/tinygo/actions/workflows/build-macos.yml) [![Windows](https://github.com/tinygo-org/tinygo/actions/workflows/windows.yml/badge.svg?branch=dev)](https://github.com/tinygo-org/tinygo/actions/workflows/windows.yml) [![Docker](https://github.com/tinygo-org/tinygo/actions/workflows/docker.yml/badge.svg?branch=dev)](https://github.com/tinygo-org/tinygo/actions/workflows/docker.yml) [![CircleCI](https://circleci.com/gh/tinygo-org/tinygo/tree/dev.svg?style=svg)](https://circleci.com/gh/tinygo-org/tinygo/tree/dev)
+[![CircleCI](https://circleci.com/gh/tinygo-org/tinygo/tree/dev.svg?style=svg)](https://circleci.com/gh/tinygo-org/tinygo/tree/dev) [![Build Status](https://dev.azure.com/tinygo/tinygo/_apis/build/status/tinygo-CI?branchName=dev)](https://dev.azure.com/tinygo/tinygo/_build/latest?definitionId=1&branchName=dev)
 
 TinyGo is a Go compiler intended for use in small places such as microcontrollers, WebAssembly (Wasm), and command-line tools.
 
@@ -43,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 80 microcontroller boards are currently supported:
+The following 71 microcontroller boards are currently supported:
 
 * [Adafruit Circuit Playground Bluefruit](https://www.adafruit.com/product/4333)
 * [Adafruit Circuit Playground Express](https://www.adafruit.com/product/3333)
@@ -79,17 +79,12 @@ The following 80 microcontroller boards are currently supported:
 * [Arduino Zero](https://store.arduino.cc/usa/arduino-zero)
 * [BBC micro:bit](https://microbit.org/)
 * [BBC micro:bit v2](https://microbit.org/new-microbit/)
-* [blues wireless Swan](https://blues.io/products/swan/)
 * [Digispark](http://digistump.com/products/1)
 * [Dragino LoRaWAN GPS Tracker LGT-92](http://www.dragino.com/products/lora-lorawan-end-node/item/142-lgt-92.html)
-* [ESP32 - Core board](https://www.espressif.com/en/products/socs/esp32)
-* [ESP32 - mini32](https://www.espressif.com/en/products/socs/esp32)
-* [ESP8266 - d1mini](https://www.espressif.com/en/products/socs/esp8266)
-* [ESP8266 - NodeMCU](https://www.espressif.com/en/products/socs/esp8266)
+* [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)
-* [M5Stamp C3](https://docs.m5stack.com/en/core/stamp_c3)
 * [Makerdiary nRF52840-MDK](https://wiki.makerdiary.com/nrf52840-mdk/)
 * [Makerdiary nRF52840-MDK USB Dongle](https://wiki.makerdiary.com/nrf52840-mdk-usb-dongle/)
 * [Microchip SAM E54 Xplained Pro](https://www.microchip.com/developmenttools/productdetails/atsame54-xpro)
@@ -109,22 +104,18 @@ The following 80 microcontroller boards are currently supported:
 * [ProductivityOpen P1AM-100](https://facts-engineering.github.io/modules/P1AM-100/P1AM-100.html)
 * [Raspberry Pi Pico](https://www.raspberrypi.org/products/raspberry-pi-pico/)
 * [Raytac MDBT50Q-RX Dongle (with TinyUF2 bootloader)](https://www.adafruit.com/product/5199)
-* [Seeed Seeeduino XIAO](https://www.seeedstudio.com/Seeeduino-XIAO-Arduino-Microcontroller-SAMD21-Cortex-M0+-p-4426.html)
-* [Seeed LoRa-E5 Development Kit](https://www.seeedstudio.com/LoRa-E5-Dev-Kit-p-4868.html)
-* [Seeed Sipeed MAix BiT](https://www.seeedstudio.com/Sipeed-MAix-BiT-for-RISC-V-AI-IoT-p-2872.html)
 * [Seeed Wio Terminal](https://www.seeedstudio.com/Wio-Terminal-p-4509.html)
-* [SiFIve HiFive1 Rev B](https://www.sifive.com/boards/hifive1)
+* [Seeed Seeeduino XIAO](https://www.seeedstudio.com/Seeeduino-XIAO-Arduino-Microcontroller-SAMD21-Cortex-M0+-p-4426.html)
+* [Seeed Sipeed MAix BiT](https://www.seeedstudio.com/Sipeed-MAix-BiT-for-RISC-V-AI-IoT-p-2872.html)
+* [SiFIve HiFive1](https://www.sifive.com/boards/hifive1)
 * [ST Micro "Nucleo" F103RB](https://www.st.com/en/evaluation-tools/nucleo-f103rb.html)
 * [ST Micro "Nucleo" F722ZE](https://www.st.com/en/evaluation-tools/nucleo-f722ze.html)
 * [ST Micro "Nucleo" L031K6](https://www.st.com/ja/evaluation-tools/nucleo-l031k6.html)
 * [ST Micro "Nucleo" L432KC](https://www.st.com/ja/evaluation-tools/nucleo-l432kc.html)
 * [ST Micro "Nucleo" L552ZE](https://www.st.com/en/evaluation-tools/nucleo-l552ze-q.html)
-* [ST Micro "Nucleo" WL55JC](https://www.st.com/en/evaluation-tools/nucleo-wl55jc.html)
 * [ST Micro STM32F103XX "Bluepill"](https://stm32-base.org/boards/STM32F103C8T6-Blue-Pill)
 * [ST Micro STM32F407 "Discovery"](https://www.st.com/en/evaluation-tools/stm32f4discovery.html)
-* [ST Micro STM32F469 "Discovery"](https://www.st.com/content/st_com/en/products/evaluation-tools/product-evaluation-tools/mcu-mpu-eval-tools/stm32-mcu-mpu-eval-tools/stm32-discovery-kits/32f469idiscovery.html)
 * [X9 Pro smartwatch](https://github.com/curtpw/nRF5x-device-reverse-engineering/tree/master/X9-nrf52832-activity-tracker/)
-* [The Things Industries Generic Node Sensor Edition](https://www.genericnode.com/docs/sensor-edition/)
 
 For more information, see [this list of boards](https://tinygo.org/microcontrollers/). Pull requests for additional support are welcome!
 
@@ -151,7 +142,7 @@ should arrive fairly quickly (under 1 min): https://invite.slack.golangbridge.or
 
 Your contributions are welcome!
 
-Please take a look at our [Contributing](https://tinygo.org/docs/guides/contributing/) page on our web site for details.
+Please take a look at our [CONTRIBUTING.md](./CONTRIBUTING.md) document for details.
 
 ## Project Scope
 
@@ -165,6 +156,7 @@ Goals:
 
 Non-goals:
 
+* Using more than one core.
 * Be efficient while using zillions of goroutines. However, good goroutine support is certainly a goal.
 * Be as fast as `gc`. However, LLVM will probably be better at optimizing certain things so TinyGo might actually turn out to be faster for number crunching.
 * Be able to compile every Go program out there.

build/.gitignore

@@ -0,0 +1,2 @@
+*
+!.gitignore

builder/build.go

@@ -23,7 +23,7 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/gofrs/flock"
+	"github.com/tinygo-org/tinygo/cgo"
 	"github.com/tinygo-org/tinygo/compileopts"
 	"github.com/tinygo-org/tinygo/compiler"
 	"github.com/tinygo-org/tinygo/goenv"
@@ -45,11 +45,6 @@ type BuildResult struct {
 	// binary must be run in the directory of the tested package.
 	MainDir string
 
-	// The root of the Go module tree.  This is used for running tests in emulator
-	// that restrict file system access to allow them to grant access to the entire
-	// source tree they're likely to need to read testdata from.
-	ModuleRoot string
-
 	// ImportPath is the import path of the main package. This is useful for
 	// correctly printing test results: the import path isn't always the same as
 	// the path listed on the command line.
@@ -68,8 +63,9 @@ type BuildResult struct {
 // implementation of an imported package changes.
 type packageAction struct {
 	ImportPath       string
-	CompilerBuildID  string
-	TinyGoVersion    string
+	CGoVersion       int // cgo.Version
+	CompilerVersion  int // compiler.Version
+	InterpVersion    int // interp.Version
 	LLVMVersion      string
 	Config           *compiler.Config
 	CFlags           []string
@@ -87,13 +83,6 @@ type packageAction struct {
 // The error value may be of type *MultiError. Callers will likely want to check
 // for this case and print such errors individually.
 func Build(pkgName, outpath string, config *compileopts.Config, action func(BuildResult) error) error {
-	// Read the build ID of the tinygo binary.
-	// Used as a cache key for package builds.
-	compilerBuildID, err := ReadBuildID()
-	if err != nil {
-		return err
-	}
-
 	// Create a temporary directory for intermediary files.
 	dir, err := ioutil.TempDir("", "tinygo")
 	if err != nil {
@@ -108,19 +97,17 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 	var libcDependencies []*compileJob
 	switch config.Target.Libc {
 	case "musl":
-		job, unlock, err := Musl.load(config, dir)
+		job, err := Musl.load(config, dir)
 		if err != nil {
 			return err
 		}
-		defer unlock()
 		libcDependencies = append(libcDependencies, dummyCompileJob(filepath.Join(filepath.Dir(job.result), "crt1.o")))
 		libcDependencies = append(libcDependencies, job)
 	case "picolibc":
-		libcJob, unlock, err := Picolibc.load(config, dir)
+		libcJob, err := Picolibc.load(config, dir)
 		if err != nil {
 			return err
 		}
-		defer unlock()
 		libcDependencies = append(libcDependencies, libcJob)
 	case "wasi-libc":
 		path := filepath.Join(root, "lib/wasi-libc/sysroot/lib/wasm32-wasi/libc.a")
@@ -129,11 +116,10 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		}
 		libcDependencies = append(libcDependencies, dummyCompileJob(path))
 	case "mingw-w64":
-		_, unlock, err := MinGW.load(config, dir)
+		_, err := MinGW.load(config, dir)
 		if err != nil {
 			return err
 		}
-		unlock()
 		libcDependencies = append(libcDependencies, makeMinGWExtraLibs(dir)...)
 	case "":
 		// no library specified, so nothing to do
@@ -153,6 +139,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		SizeLevel:       sizeLevel,
 
 		Scheduler:          config.Scheduler(),
+		FuncImplementation: config.FuncImplementation(),
 		AutomaticStackSize: config.AutomaticStackSize(),
 		DefaultStackSize:   config.Target.DefaultStackSize,
 		NeedsStackObjects:  config.NeedsStackObjects(),
@@ -201,8 +188,9 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		// the parameters for the build.
 		actionID := packageAction{
 			ImportPath:       pkg.ImportPath,
-			CompilerBuildID:  string(compilerBuildID),
-			TinyGoVersion:    goenv.Version,
+			CGoVersion:       cgo.Version,
+			CompilerVersion:  compiler.Version,
+			InterpVersion:    interp.Version,
 			LLVMVersion:      llvm.Version,
 			Config:           compilerConfig,
 			CFlags:           pkg.CFlags,
@@ -240,19 +228,17 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		bitcodePath := filepath.Join(cacheDir, "pkg-"+hex.EncodeToString(hash[:])+".bc")
 		packageBitcodePaths[pkg.ImportPath] = bitcodePath
 
+		// Check whether this package has been compiled before, and if so don't
+		// compile it again.
+		if _, err := os.Stat(bitcodePath); err == nil {
+			// Already cached, don't recreate this package.
+			continue
+		}
+
 		// The package has not yet been compiled, so create a job to do so.
 		job := &compileJob{
 			description: "compile package " + pkg.ImportPath,
 			run: func(*compileJob) error {
-				// Acquire a lock (if supported).
-				unlock := lock(bitcodePath + ".lock")
-				defer unlock()
-
-				if _, err := os.Stat(bitcodePath); err == nil {
-					// Already cached, don't recreate this package.
-					return nil
-				}
-
 				// Compile AST to IR. The compiler.CompilePackage function will
 				// build the SSA as needed.
 				mod, errs := compiler.CompilePackage(pkg.ImportPath, pkg, program.Package(pkg.Pkg), machine, compilerConfig, config.DumpSSA())
@@ -428,6 +414,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 			llvmInitFn.SetUnnamedAddr(true)
 			transform.AddStandardAttributes(llvmInitFn, config)
 			llvmInitFn.Param(0).SetName("context")
+			llvmInitFn.Param(1).SetName("parentHandle")
 			block := mod.Context().AddBasicBlock(llvmInitFn, "entry")
 			irbuilder := mod.Context().NewBuilder()
 			defer irbuilder.Dispose()
@@ -438,7 +425,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 				if pkgInit.IsNil() {
 					panic("init not found for " + pkg.Pkg.Path())
 				}
-				irbuilder.CreateCall(pkgInit, []llvm.Value{llvm.Undef(i8ptrType)}, "")
+				irbuilder.CreateCall(pkgInit, []llvm.Value{llvm.Undef(i8ptrType), llvm.Undef(i8ptrType)}, "")
 			}
 			irbuilder.CreateRetVoid()
 
@@ -492,7 +479,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 	outext := filepath.Ext(outpath)
 	if outext == ".o" || outext == ".bc" || outext == ".ll" {
 		// Run jobs to produce the LLVM module.
-		err := runJobs(programJob, config.Options.Semaphore)
+		err := runJobs(programJob, config.Options.Parallelism)
 		if err != nil {
 			return err
 		}
@@ -546,11 +533,10 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 	// Add compiler-rt dependency if needed. Usually this is a simple load from
 	// a cache.
 	if config.Target.RTLib == "compiler-rt" {
-		job, unlock, err := CompilerRT.load(config, dir)
+		job, err := CompilerRT.load(config, dir)
 		if err != nil {
 			return err
 		}
-		defer unlock()
 		linkerDependencies = append(linkerDependencies, job)
 	}
 
@@ -754,7 +740,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 	// 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.Semaphore)
+	err = runJobs(linkJob, config.Options.Parallelism)
 	if err != nil {
 		return err
 	}
@@ -802,18 +788,9 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 	default:
 		return fmt.Errorf("unknown output binary format: %s", outputBinaryFormat)
 	}
-
-	// If there's a module root, use that.
-	moduleroot := lprogram.MainPkg().Module.Dir
-	if moduleroot == "" {
-		// if not, just the regular root
-		moduleroot = lprogram.MainPkg().Root
-	}
-
 	return action(BuildResult{
 		Binary:     tmppath,
 		MainDir:    lprogram.MainPkg().Dir,
-		ModuleRoot: moduleroot,
 		ImportPath: lprogram.MainPkg().ImportPath,
 	})
 }
@@ -1204,16 +1181,3 @@ func patchRP2040BootCRC(executable string) error {
 	// Update the .boot2 section to included the CRC
 	return replaceElfSection(executable, ".boot2", bytes)
 }
-
-// lock may acquire a lock at the specified path.
-// It returns a function to release the lock.
-// If flock is not supported, it does nothing.
-func lock(path string) func() {
-	flock := flock.New(path)
-	err := flock.Lock()
-	if err != nil {
-		return func() {}
-	}
-
-	return func() { flock.Close() }
-}

builder/builder_test.go

@@ -5,7 +5,6 @@ import (
 	"io/ioutil"
 	"os"
 	"path/filepath"
-	"runtime"
 	"testing"
 
 	"github.com/tinygo-org/tinygo/compileopts"
@@ -61,11 +60,7 @@ func TestClangAttributes(t *testing.T) {
 		{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) {
+		t.Run("GOOS="+options.GOOS+",GOARCH="+options.GOARCH, func(t *testing.T) {
 			testClangAttributes(t, options)
 		})
 	}
@@ -136,12 +131,12 @@ func testClangAttributes(t *testing.T, options *compileopts.Options) {
 		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)
+		if llvm.Version != "11.0.0" {
+			// This needs to be removed once we switch to LLVM 12.
+			// LLVM 11.0.0 uses a different "target-features" string than LLVM
+			// 11.1.0 for Thumb targets. The Xtensa fork is still based on LLVM
+			// 11.0.0, so we need to skip this check on that version.
+			t.Errorf("target has LLVM features %#v but Clang makes it %#v", config.Features(), features)
 		}
 	}
 }

builder/buildid.go

@@ -1,93 +0,0 @@
-package builder
-
-import (
-	"bytes"
-	"debug/elf"
-	"debug/macho"
-	"encoding/binary"
-	"fmt"
-	"io"
-	"os"
-	"runtime"
-)
-
-// ReadBuildID reads the build ID from the currently running executable.
-func ReadBuildID() ([]byte, error) {
-	executable, err := os.Executable()
-	if err != nil {
-		return nil, err
-	}
-	f, err := os.Open(executable)
-	if err != nil {
-		return nil, err
-	}
-	defer f.Close()
-
-	switch runtime.GOOS {
-	case "linux", "freebsd":
-		// Read the GNU build id section. (Not sure about FreeBSD though...)
-		file, err := elf.NewFile(f)
-		if err != nil {
-			return nil, err
-		}
-		for _, section := range file.Sections {
-			if section.Type != elf.SHT_NOTE ||
-				(section.Name != ".note.gnu.build-id" && section.Name != ".note.go.buildid") {
-				continue
-			}
-			buf := make([]byte, section.Size)
-			n, err := section.ReadAt(buf, 0)
-			if uint64(n) != section.Size || err != nil {
-				return nil, fmt.Errorf("could not read build id: %w", err)
-			}
-			return buf, nil
-		}
-	case "darwin":
-		// Read the LC_UUID load command, which contains the equivalent of a
-		// build ID.
-		file, err := macho.NewFile(f)
-		if err != nil {
-			return nil, err
-		}
-		for _, load := range file.Loads {
-			// Unfortunately, the debug/macho package doesn't support the
-			// LC_UUID command directly. So we have to read it from
-			// macho.LoadBytes.
-			load, ok := load.(macho.LoadBytes)
-			if !ok {
-				continue
-			}
-			raw := load.Raw()
-			command := binary.LittleEndian.Uint32(raw)
-			if command != 0x1b {
-				// Looking for the LC_UUID load command.
-				// LC_UUID is defined here as 0x1b:
-				// https://opensource.apple.com/source/xnu/xnu-4570.71.2/EXTERNAL_HEADERS/mach-o/loader.h.auto.html
-				continue
-			}
-			return raw[4:], nil
-		}
-	default:
-		// On other platforms (such as Windows) there isn't such a convenient
-		// build ID. Luckily, Go does have an equivalent of the build ID, which
-		// is stored as a special symbol named go.buildid. You can read it
-		// using `go tool buildid`, but the code below extracts it directly
-		// from the binary.
-		// Unfortunately, because of stripping with the -w flag, no symbol
-		// table might be available. Therefore, we have to scan the binary
-		// directly. Luckily the build ID is always at the start of the file.
-		// For details, see:
-		// https://github.com/golang/go/blob/master/src/cmd/internal/buildid/buildid.go
-		fileStart := make([]byte, 4096)
-		_, err := io.ReadFull(f, fileStart)
-		index := bytes.Index(fileStart, []byte("\xff Go build ID: \""))
-		if index < 0 || index > len(fileStart)-103 {
-			return nil, fmt.Errorf("could not find build id in %s", err)
-		}
-		buf := fileStart[index : index+103]
-		if bytes.HasPrefix(buf, []byte("\xff Go build ID: \"")) && bytes.HasSuffix(buf, []byte("\"\n \xff")) {
-			return buf[len("\xff Go build ID: \"") : len(buf)-1], nil
-		}
-	}
-	return nil, fmt.Errorf("could not find build ID in %s", executable)
-}

builder/cc.go

@@ -63,10 +63,6 @@ func compileAndCacheCFile(abspath, tmpdir string, cflags []string, printCommands
 		return "", err
 	}
 
-	// Acquire a lock (if supported).
-	unlock := lock(filepath.Join(goenv.Get("GOCACHE"), fileHash+".c.lock"))
-	defer unlock()
-
 	// Create cache key for the dependencies file.
 	buf, err := json.Marshal(struct {
 		Path        string

builder/cc1as.cpp

@@ -115,26 +115,29 @@ bool AssemblerInvocation::CreateFromArgs(AssemblerInvocation &Opts,
   // Any DebugInfoKind implies GenDwarfForAssembly.
   Opts.GenDwarfForAssembly = Args.hasArg(OPT_debug_info_kind_EQ);
 
-  if (const Arg *A = Args.getLastArg(OPT_compress_debug_sections_EQ)) {
-    Opts.CompressDebugSections =
-        llvm::StringSwitch<llvm::DebugCompressionType>(A->getValue())
-            .Case("none", llvm::DebugCompressionType::None)
-            .Case("zlib", llvm::DebugCompressionType::Z)
-            .Case("zlib-gnu", llvm::DebugCompressionType::GNU)
-            .Default(llvm::DebugCompressionType::None);
+  if (const Arg *A = Args.getLastArg(OPT_compress_debug_sections,
+                                     OPT_compress_debug_sections_EQ)) {
+    if (A->getOption().getID() == OPT_compress_debug_sections) {
+      // TODO: be more clever about the compression type auto-detection
+      Opts.CompressDebugSections = llvm::DebugCompressionType::GNU;
+    } else {
+      Opts.CompressDebugSections =
+          llvm::StringSwitch<llvm::DebugCompressionType>(A->getValue())
+              .Case("none", llvm::DebugCompressionType::None)
+              .Case("zlib", llvm::DebugCompressionType::Z)
+              .Case("zlib-gnu", llvm::DebugCompressionType::GNU)
+              .Default(llvm::DebugCompressionType::None);
+    }
   }
 
   Opts.RelaxELFRelocations = Args.hasArg(OPT_mrelax_relocations);
-  if (auto *DwarfFormatArg = Args.getLastArg(OPT_gdwarf64, OPT_gdwarf32))
-    Opts.Dwarf64 = DwarfFormatArg->getOption().matches(OPT_gdwarf64);
   Opts.DwarfVersion = getLastArgIntValue(Args, OPT_dwarf_version_EQ, 2, Diags);
   Opts.DwarfDebugFlags =
       std::string(Args.getLastArgValue(OPT_dwarf_debug_flags));
   Opts.DwarfDebugProducer =
       std::string(Args.getLastArgValue(OPT_dwarf_debug_producer));
-  if (const Arg *A = Args.getLastArg(options::OPT_ffile_compilation_dir_EQ,
-                                     options::OPT_fdebug_compilation_dir_EQ))
-    Opts.DebugCompilationDir = A->getValue();
+  Opts.DebugCompilationDir =
+      std::string(Args.getLastArgValue(OPT_fdebug_compilation_dir));
   Opts.MainFileName = std::string(Args.getLastArgValue(OPT_main_file_name));
 
   for (const auto &Arg : Args.getAllArgValues(OPT_fdebug_prefix_map_EQ)) {
@@ -216,7 +219,7 @@ getOutputStream(StringRef Path, DiagnosticsEngine &Diags, bool Binary) {
 
   std::error_code EC;
   auto Out = std::make_unique<raw_fd_ostream>(
-      Path, EC, (Binary ? sys::fs::OF_None : sys::fs::OF_TextWithCRLF));
+      Path, EC, (Binary ? sys::fs::OF_None : sys::fs::OF_Text));
   if (EC) {
     Diags.Report(diag::err_fe_unable_to_open_output) << Path << EC.message();
     return nullptr;
@@ -225,8 +228,7 @@ getOutputStream(StringRef Path, DiagnosticsEngine &Diags, bool Binary) {
   return Out;
 }
 
-static bool ExecuteAssemblerImpl(AssemblerInvocation &Opts,
-                                 DiagnosticsEngine &Diags) {
+bool ExecuteAssembler(AssemblerInvocation &Opts, DiagnosticsEngine &Diags) {
   // Get the target specific parser.
   std::string Error;
   const Target *TheTarget = TargetRegistry::lookupTarget(Opts.Triple, Error);
@@ -234,7 +236,7 @@ static bool ExecuteAssemblerImpl(AssemblerInvocation &Opts,
     return Diags.Report(diag::err_target_unknown_triple) << Opts.Triple;
 
   ErrorOr<std::unique_ptr<MemoryBuffer>> Buffer =
-      MemoryBuffer::getFileOrSTDIN(Opts.InputFile, /*IsText=*/true);
+      MemoryBuffer::getFileOrSTDIN(Opts.InputFile);
 
   if (std::error_code EC = Buffer.getError()) {
     Error = EC.message();
@@ -275,15 +277,11 @@ static bool ExecuteAssemblerImpl(AssemblerInvocation &Opts,
   if (!Opts.SplitDwarfOutput.empty())
     DwoOS = getOutputStream(Opts.SplitDwarfOutput, Diags, IsBinary);
 
-  // Build up the feature string from the target feature list.
-  std::string FS = llvm::join(Opts.Features, ",");
+  // FIXME: This is not pretty. MCContext has a ptr to MCObjectFileInfo and
+  // MCObjectFileInfo needs a MCContext reference in order to initialize itself.
+  std::unique_ptr<MCObjectFileInfo> MOFI(new MCObjectFileInfo());
 
-  std::unique_ptr<MCSubtargetInfo> STI(
-      TheTarget->createMCSubtargetInfo(Opts.Triple, Opts.CPU, FS));
-  assert(STI && "Unable to create subtarget info!");
-
-  MCContext Ctx(Triple(Opts.Triple), MAI.get(), MRI.get(), STI.get(), &SrcMgr,
-                &MCOptions);
+  MCContext Ctx(MAI.get(), MRI.get(), MOFI.get(), &SrcMgr, &MCOptions);
 
   bool PIC = false;
   if (Opts.RelocationModel == "static") {
@@ -296,12 +294,7 @@ static bool ExecuteAssemblerImpl(AssemblerInvocation &Opts,
     PIC = false;
   }
 
-  // FIXME: This is not pretty. MCContext has a ptr to MCObjectFileInfo and
-  // MCObjectFileInfo needs a MCContext reference in order to initialize itself.
-  std::unique_ptr<MCObjectFileInfo> MOFI(
-      TheTarget->createMCObjectFileInfo(Ctx, PIC));
-  Ctx.setObjectFileInfo(MOFI.get());
-
+  MOFI->InitMCObjectFileInfo(Triple(Opts.Triple), PIC, Ctx);
   if (Opts.SaveTemporaryLabels)
     Ctx.setAllowTemporaryLabels(false);
   if (Opts.GenDwarfForAssembly)
@@ -323,16 +316,19 @@ static bool ExecuteAssemblerImpl(AssemblerInvocation &Opts,
       Ctx.addDebugPrefixMapEntry(KV.first, KV.second);
   if (!Opts.MainFileName.empty())
     Ctx.setMainFileName(StringRef(Opts.MainFileName));
-  Ctx.setDwarfFormat(Opts.Dwarf64 ? dwarf::DWARF64 : dwarf::DWARF32);
   Ctx.setDwarfVersion(Opts.DwarfVersion);
   if (Opts.GenDwarfForAssembly)
     Ctx.setGenDwarfRootFile(Opts.InputFile,
                             SrcMgr.getMemoryBuffer(BufferIndex)->getBuffer());
 
+  // Build up the feature string from the target feature list.
+  std::string FS = llvm::join(Opts.Features, ",");
+
   std::unique_ptr<MCStreamer> Str;
 
   std::unique_ptr<MCInstrInfo> MCII(TheTarget->createMCInstrInfo());
-  assert(MCII && "Unable to create instruction info!");
+  std::unique_ptr<MCSubtargetInfo> STI(
+      TheTarget->createMCSubtargetInfo(Opts.Triple, Opts.CPU, FS));
 
   raw_pwrite_stream *Out = FDOS.get();
   std::unique_ptr<buffer_ostream> BOS;
@@ -371,8 +367,6 @@ static bool ExecuteAssemblerImpl(AssemblerInvocation &Opts,
         TheTarget->createMCCodeEmitter(*MCII, *MRI, Ctx));
     std::unique_ptr<MCAsmBackend> MAB(
         TheTarget->createMCAsmBackend(*STI, *MRI, MCOptions));
-    assert(MAB && "Unable to create asm backend!");
-
     std::unique_ptr<MCObjectWriter> OW =
         DwoOS ? MAB->createDwoObjectWriter(*Out, *DwoOS)
               : MAB->createObjectWriter(*Out);
@@ -387,7 +381,8 @@ static bool ExecuteAssemblerImpl(AssemblerInvocation &Opts,
 
   // When -fembed-bitcode is passed to clang_as, a 1-byte marker
   // is emitted in __LLVM,__asm section if the object file is MachO format.
-  if (Opts.EmbedBitcode && Ctx.getObjectFileType() == MCContext::IsMachO) {
+  if (Opts.EmbedBitcode && Ctx.getObjectFileInfo()->getObjectFileType() ==
+                               MCObjectFileInfo::IsMachO) {
     MCSection *AsmLabel = Ctx.getMachOSection(
         "__LLVM", "__asm", MachO::S_REGULAR, 4, SectionKind::getReadOnly());
     Str.get()->SwitchSection(AsmLabel);
@@ -424,12 +419,12 @@ static bool ExecuteAssemblerImpl(AssemblerInvocation &Opts,
     Failed = Parser->Run(Opts.NoInitialTextSection);
   }
 
-  return Failed;
-}
-
-bool ExecuteAssembler(AssemblerInvocation &Opts,
-                             DiagnosticsEngine &Diags) {
-  bool Failed = ExecuteAssemblerImpl(Opts, Diags);
+  // Close Streamer first.
+  // It might have a reference to the output stream.
+  Str.reset();
+  // Close the output stream early.
+  BOS.reset();
+  FDOS.reset();
 
   // Delete output file if there were errors.
   if (Failed) {
@@ -477,7 +472,7 @@ int cc1as_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
     return 1;
 
   if (Asm.ShowHelp) {
-    getDriverOptTable().printHelp(
+    getDriverOptTable().PrintHelp(
         llvm::outs(), "clang -cc1as [options] file...",
         "Clang Integrated Assembler",
         /*Include=*/driver::options::CC1AsOption, /*Exclude=*/0,

builder/cc1as.h

@@ -39,7 +39,6 @@ struct AssemblerInvocation {
   unsigned SaveTemporaryLabels : 1;
   unsigned GenDwarfForAssembly : 1;
   unsigned RelaxELFRelocations : 1;
-  unsigned Dwarf64 : 1;
   unsigned DwarfVersion;
   std::string DwarfDebugFlags;
   std::string DwarfDebugProducer;
@@ -109,7 +108,6 @@ public:
     FatalWarnings = 0;
     NoWarn = 0;
     IncrementalLinkerCompatible = 0;
-    Dwarf64 = 0;
     DwarfVersion = 0;
     EmbedBitcode = 0;
   }

builder/commands.go

@@ -2,7 +2,6 @@ package builder
 
 import (
 	"errors"
-	"fmt"
 	"os"
 	"os/exec"
 	"runtime"
@@ -26,16 +25,7 @@ func init() {
 	// Add the path to a Homebrew-installed LLVM for ease of use (no need to
 	// manually set $PATH).
 	if runtime.GOOS == "darwin" {
-		var prefix string
-		switch runtime.GOARCH {
-		case "amd64":
-			prefix = "/usr/local/opt/llvm@" + llvmMajor + "/bin/"
-		case "arm64":
-			prefix = "/opt/homebrew/opt/llvm@" + llvmMajor + "/bin/"
-		default:
-			// unknown GOARCH
-			panic(fmt.Sprintf("unknown GOARCH: %s on darwin", runtime.GOARCH))
-		}
+		prefix := "/usr/local/opt/llvm@" + llvmMajor + "/bin/"
 		commands["clang"] = append(commands["clang"], prefix+"clang-"+llvmMajor)
 		commands["ld.lld"] = append(commands["ld.lld"], prefix+"ld.lld")
 		commands["wasm-ld"] = append(commands["wasm-ld"], prefix+"wasm-ld")

builder/env.go

@@ -84,20 +84,6 @@ func getClangHeaderPath(TINYGOROOT string) string {
 		}
 	}
 
-	// On Arch Linux, the clang executable is stored in /usr/bin rather than being symlinked from there.
-	// Search directly in /usr/lib for clang.
-	if matches, err := filepath.Glob("/usr/lib/clang/" + llvmMajor + ".*.*"); err == nil {
-		// Check for the highest version first.
-		sort.Strings(matches)
-		for i := len(matches) - 1; i >= 0; i-- {
-			path := filepath.Join(matches[i], "include")
-			_, err := os.Stat(filepath.Join(path, "stdint.h"))
-			if err == nil {
-				return path
-			}
-		}
-	}
-
 	// Could not find it.
 	return ""
 }

builder/jobs.go

@@ -4,12 +4,8 @@ package builder
 // parallel while taking care of dependencies.
 
 import (
-	"container/heap"
-	"errors"
 	"fmt"
 	"runtime"
-	"sort"
-	"strings"
 	"time"
 )
 
@@ -33,6 +29,7 @@ type compileJob struct {
 	dependencies []*compileJob
 	result       string // result (path)
 	run          func(*compileJob) (err error)
+	state        jobState
 	err          error         // error if finished
 	duration     time.Duration // how long it took to run this job (only set after finishing)
 }
@@ -47,20 +44,41 @@ func dummyCompileJob(result string) *compileJob {
 	}
 }
 
+// readyToRun returns whether this job is ready to run: it is itself not yet
+// started and all dependencies are finished.
+func (job *compileJob) readyToRun() bool {
+	if job.state != jobStateQueued {
+		// Already running or finished, so shouldn't be run again.
+		return false
+	}
+
+	// Check dependencies.
+	for _, dep := range job.dependencies {
+		if dep.state != jobStateFinished {
+			// A dependency is not finished, so this job has to wait until it
+			// is.
+			return false
+		}
+	}
+
+	// All conditions are satisfied.
+	return true
+}
+
 // runJobs runs the indicated job and all its dependencies. For every job, all
 // the dependencies are run first. It returns the error of the first job that
 // fails.
 // It runs all jobs in the order of the dependencies slice, depth-first.
 // Therefore, if some jobs are preferred to run before others, they should be
 // ordered as such in the job dependencies.
-func runJobs(job *compileJob, sema chan struct{}) error {
-	if sema == nil {
-		// Have a default, if the semaphore isn't set. This is useful for
+func runJobs(job *compileJob, parallelism int) error {
+	if parallelism == 0 {
+		// Have a default, if the parallelism isn't set. This is useful for
 		// tests.
-		sema = make(chan struct{}, runtime.NumCPU())
+		parallelism = runtime.NumCPU()
 	}
-	if cap(sema) == 0 {
-		return errors.New("cannot 0 jobs at a time")
+	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.
@@ -79,91 +97,64 @@ func runJobs(job *compileJob, sema chan struct{}) error {
 	}
 	addJobs(job)
 
-	waiting := make(map[*compileJob]map[*compileJob]struct{}, len(jobs))
-	dependents := make(map[*compileJob][]*compileJob, len(jobs))
-	jidx := make(map[*compileJob]int)
-	var ready intHeap
-	for i, job := range jobs {
-		jidx[job] = i
-		if len(job.dependencies) == 0 {
-			// This job is ready to run.
-			ready.Push(i)
-			continue
-		}
-
-		// Construct a map for dependencies which the job is currently waiting on.
-		waitDeps := make(map[*compileJob]struct{})
-		waiting[job] = waitDeps
-
-		// Add the job to the dependents list of each dependency.
-		for _, dep := range job.dependencies {
-			dependents[dep] = append(dependents[dep], job)
-			waitDeps[dep] = struct{}{}
-		}
-	}
-
-	// Create a channel to accept notifications of completion.
+	// Create channels to communicate with the workers.
 	doneChan := make(chan *compileJob)
+	workerChan := make(chan *compileJob)
+	defer close(workerChan)
+
+	// Start a number of workers.
+	for i := 0; i < parallelism; i++ {
+		if jobRunnerDebug {
+			fmt.Println("## starting worker", i)
+		}
+		go jobWorker(workerChan, doneChan)
+	}
 
 	// Send each job in the jobs slice to a worker, taking care of job
 	// dependencies.
 	numRunningJobs := 0
 	var totalTime time.Duration
 	start := time.Now()
-	for len(ready.IntSlice) > 0 || numRunningJobs != 0 {
-		var completed *compileJob
-		if len(ready.IntSlice) > 0 {
-			select {
-			case sema <- struct{}{}:
-				// Start a job.
-				job := jobs[heap.Pop(&ready).(int)]
+	for {
+		// If there are free workers, try starting a new job (if one is
+		// available). If it succeeds, try again to fill the entire worker pool.
+		if numRunningJobs < parallelism {
+			jobToRun := nextJob(jobs)
+			if jobToRun != nil {
+				// Start job.
 				if jobRunnerDebug {
-					fmt.Println("## start:   ", job.description)
+					fmt.Println("## start:   ", jobToRun.description)
 				}
-				go runJob(job, doneChan)
+				jobToRun.state = jobStateRunning
+				workerChan <- jobToRun
 				numRunningJobs++
 				continue
-
-			case completed = <-doneChan:
-				// A job completed.
 			}
-		} else {
-			// Wait for a job to complete.
-			completed = <-doneChan
 		}
+
+		// When there are no jobs running, all jobs in the jobs slice must have
+		// been finished. Therefore, the work is done.
+		if numRunningJobs == 0 {
+			break
+		}
+
+		// Wait until a job is finished.
+		job := <-doneChan
+		job.state = jobStateFinished
 		numRunningJobs--
-		<-sema
+		totalTime += job.duration
 		if jobRunnerDebug {
 			fmt.Println("## finished:", job.description, "(time "+job.duration.String()+")")
 		}
-		if completed.err != nil {
-			// Wait for any current jobs to finish.
+		if job.err != nil {
+			// Wait for running jobs to finish.
 			for numRunningJobs != 0 {
 				<-doneChan
 				numRunningJobs--
 			}
-
-			// The build failed.
-			return completed.err
+			// Return error of first failing job.
+			return job.err
 		}
-
-		// Update total run time.
-		totalTime += completed.duration
-
-		// Update dependent jobs.
-		for _, j := range dependents[completed] {
-			wait := waiting[j]
-			delete(wait, completed)
-			if len(wait) == 0 {
-				// This job is now ready to run.
-				ready.Push(jidx[j])
-				delete(waiting, j)
-			}
-		}
-	}
-	if len(waiting) != 0 {
-		// There is a dependency cycle preventing some jobs from running.
-		return errDependencyCycle{waiting}
 	}
 
 	// Some statistics, if debugging.
@@ -180,50 +171,29 @@ func runJobs(job *compileJob, sema chan struct{}) error {
 	return nil
 }
 
-type errDependencyCycle struct {
-	waiting map[*compileJob]map[*compileJob]struct{}
-}
-
-func (err errDependencyCycle) Error() string {
-	waits := make([]string, 0, len(err.waiting))
-	for j, wait := range err.waiting {
-		deps := make([]string, 0, len(wait))
-		for dep := range wait {
-			deps = append(deps, dep.description)
-		}
-		sort.Strings(deps)
-
-		waits = append(waits, fmt.Sprintf("\t%s is waiting for [%s]",
-			j.description, strings.Join(deps, ", "),
-		))
-	}
-	sort.Strings(waits)
-	return "deadlock:\n" + strings.Join(waits, "\n")
-}
-
-type intHeap struct {
-	sort.IntSlice
-}
-
-func (h *intHeap) Push(x interface{}) {
-	h.IntSlice = append(h.IntSlice, x.(int))
-}
-
-func (h *intHeap) Pop() interface{} {
-	x := h.IntSlice[len(h.IntSlice)-1]
-	h.IntSlice = h.IntSlice[:len(h.IntSlice)-1]
-	return x
-}
-
-// runJob runs a compile job and notifies doneChan of completion.
-func runJob(job *compileJob, doneChan chan *compileJob) {
-	start := time.Now()
-	if job.run != nil {
-		err := job.run(job)
-		if err != nil {
-			job.err = err
+// nextJob returns the first ready-to-run job.
+// This is an implementation detail of runJobs.
+func nextJob(jobs []*compileJob) *compileJob {
+	for _, job := range jobs {
+		if job.readyToRun() {
+			return job
 		}
 	}
-	job.duration = time.Since(start)
-	doneChan <- job
+	return nil
+}
+
+// jobWorker is the goroutine that runs received jobs.
+// This is an implementation detail of runJobs.
+func jobWorker(workerChan, doneChan chan *compileJob) {
+	for job := range workerChan {
+		start := time.Now()
+		if job.run != nil {
+			err := job.run(job)
+			if err != nil {
+				job.err = err
+			}
+		}
+		job.duration = time.Since(start)
+		doneChan <- job
+	}
 }

builder/library.go

@@ -4,9 +4,7 @@ import (
 	"io/ioutil"
 	"os"
 	"path/filepath"
-	"runtime"
 	"strings"
-	"sync"
 
 	"github.com/tinygo-org/tinygo/compileopts"
 	"github.com/tinygo-org/tinygo/goenv"
@@ -38,12 +36,11 @@ type Library struct {
 // The resulting directory may be stored in the provided tmpdir, which is
 // expected to be removed after the Load call.
 func (l *Library) Load(config *compileopts.Config, tmpdir string) (dir string, err error) {
-	job, unlock, err := l.load(config, tmpdir)
+	job, err := l.load(config, tmpdir)
 	if err != nil {
 		return "", err
 	}
-	defer unlock()
-	err = runJobs(job, config.Options.Semaphore)
+	err = runJobs(job, config.Options.Parallelism)
 	return filepath.Dir(job.result), err
 }
 
@@ -55,38 +52,28 @@ func (l *Library) Load(config *compileopts.Config, tmpdir string) (dir string, e
 // output archive file, it is expected to be removed after use.
 // As a side effect, this call creates the library header files if they didn't
 // exist yet.
-func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJob, abortLock func(), err error) {
+func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJob, err error) {
 	outdir, precompiled := config.LibcPath(l.name)
 	archiveFilePath := filepath.Join(outdir, "lib.a")
 	if precompiled {
 		// Found a precompiled library for this OS/architecture. Return the path
 		// directly.
-		return dummyCompileJob(archiveFilePath), func() {}, nil
+		return dummyCompileJob(archiveFilePath), nil
 	}
 
-	// Create a lock on the output (if supported).
-	// This is a bit messy, but avoids a deadlock because it is ordered consistently with other library loads within a build.
-	outname := filepath.Base(outdir)
-	unlock := lock(filepath.Join(goenv.Get("GOCACHE"), outname+".lock"))
-	var ok bool
-	defer func() {
-		if !ok {
-			unlock()
-		}
-	}()
-
 	// Try to fetch this library from the cache.
 	if _, err := os.Stat(archiveFilePath); err == nil {
-		return dummyCompileJob(archiveFilePath), func() {}, nil
+		return dummyCompileJob(archiveFilePath), nil
 	}
 	// Cache miss, build it now.
 
 	// Create the destination directory where the components of this library
 	// (lib.a file, include directory) are placed.
+	outname := filepath.Base(outdir)
 	err = os.MkdirAll(filepath.Join(goenv.Get("GOCACHE"), outname), 0o777)
 	if err != nil {
 		// Could not create directory (and not because it already exists).
-		return nil, nil, err
+		return nil, err
 	}
 
 	// Make headers if needed.
@@ -96,32 +83,16 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 		if _, err = os.Stat(headerPath); err != nil {
 			temporaryHeaderPath, err := ioutil.TempDir(outdir, "include.tmp*")
 			if err != nil {
-				return nil, nil, err
+				return nil, err
 			}
 			defer os.RemoveAll(temporaryHeaderPath)
 			err = l.makeHeaders(target, temporaryHeaderPath)
 			if err != nil {
-				return nil, nil, err
+				return nil, err
 			}
 			err = os.Rename(temporaryHeaderPath, headerPath)
 			if err != nil {
-				switch {
-				case os.IsExist(err):
-					// Another invocation of TinyGo also seems to have already created the headers.
-
-				case runtime.GOOS == "windows" && os.IsPermission(err):
-					// On Windows, a rename with a destination directory that already
-					// exists does not result in an IsExist error, but rather in an
-					// access denied error. To be sure, check for this case by checking
-					// whether the target directory exists.
-					if _, err := os.Stat(headerPath); err == nil {
-						break
-					}
-					fallthrough
-
-				default:
-					return nil, nil, err
-				}
+				return nil, err
 			}
 		}
 	}
@@ -130,7 +101,7 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 	dir := filepath.Join(tmpdir, "build-lib-"+l.name)
 	err = os.Mkdir(dir, 0777)
 	if err != nil {
-		return nil, nil, err
+		return nil, err
 	}
 
 	// Precalculate the flags to the compiler invocation.
@@ -149,7 +120,7 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 		}
 	}
 	if strings.HasPrefix(target, "arm") || strings.HasPrefix(target, "thumb") {
-		args = append(args, "-fshort-enums", "-fomit-frame-pointer", "-mfloat-abi=soft", "-fno-unwind-tables")
+		args = append(args, "-fshort-enums", "-fomit-frame-pointer", "-mfloat-abi=soft")
 	}
 	if strings.HasPrefix(target, "riscv32-") {
 		args = append(args, "-march=rv32imac", "-mabi=ilp32", "-fforce-enable-int128")
@@ -158,8 +129,6 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 		args = append(args, "-march=rv64gc", "-mabi=lp64")
 	}
 
-	var once sync.Once
-
 	// Create job to put all the object files in a single archive. This archive
 	// file is the (static) library file.
 	var objs []string
@@ -167,8 +136,6 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 		description: "ar " + l.name + "/lib.a",
 		result:      filepath.Join(goenv.Get("GOCACHE"), outname, "lib.a"),
 		run: func(*compileJob) error {
-			defer once.Do(unlock)
-
 			// Create an archive of all object files.
 			f, err := ioutil.TempFile(outdir, "libc.a.tmp*")
 			if err != nil {
@@ -240,8 +207,5 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 		})
 	}
 
-	ok = true
-	return job, func() {
-		once.Do(unlock)
-	}, nil
+	return job, nil
 }

builder/musl.go

@@ -101,7 +101,6 @@ var Musl = Library{
 			"-I" + muslDir + "/src/internal",
 			"-I" + headerPath,
 			"-I" + muslDir + "/include",
-			"-fno-stack-protector",
 		}
 	},
 	sourceDir: "lib/musl/src",

builder/picolibc.go

@@ -28,7 +28,7 @@ var Picolibc = Library{
 			"-DHAVE_ALIAS_ATTRIBUTE",
 			"-DTINY_STDIO",
 			"-nostdlibinc",
-			"-isystem", picolibcDir + "/include",
+			"-Xclang", "-internal-isystem", "-Xclang", picolibcDir + "/include",
 			"-I" + picolibcDir + "/tinystdio",
 			"-I" + headerPath,
 		}

builder/sizes.go

@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"debug/dwarf"
 	"debug/elf"
-	"debug/pe"
 	"encoding/binary"
 	"fmt"
 	"io"
@@ -97,17 +96,6 @@ const (
 	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 (
@@ -368,72 +356,6 @@ func loadProgramSize(path string, packagePathMap map[string]string) (*programSiz
 				})
 			}
 		}
-	} 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.
 
@@ -591,11 +513,8 @@ func readSection(section memorySection, addresses []addressLine, addSize func(st
 	// 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 {
+		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).
@@ -606,7 +525,7 @@ func readSection(section memorySection, addresses []addressLine, addSize func(st
 			// 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)
+				fmt.Printf("%08x..%08x %4d: unknown (gap)\n", addr, line.Address, line.Address-addr)
 			}
 		}
 		if addr > line.Address+line.Length {
@@ -631,7 +550,7 @@ func readSection(section memorySection, addresses []addressLine, addSize func(st
 		// 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)
+			fmt.Printf("%08x..%08x %4d: unknown (end)\n", addr, sectionEnd, sectionEnd-addr)
 		}
 	}
 }

cgo/cgo.go

@@ -14,7 +14,6 @@ package cgo
 import (
 	"fmt"
 	"go/ast"
-	"go/parser"
 	"go/scanner"
 	"go/token"
 	"path/filepath"
@@ -26,6 +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
@@ -157,39 +162,6 @@ 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
@@ -230,31 +202,58 @@ func Process(files []*ast.File, dir string, fset *token.FileSet, cflags []string
 	p.packageDir = 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{
+							{
+								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 {
@@ -497,14 +496,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,
@@ -521,10 +512,14 @@ 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{
+					{
+						Slash: fn.pos,
+						Text:  "//go:variadic",
+					},
+				},
+			}
 		}
 		obj.Decl = decl
 		for i, arg := range fn.args {
@@ -657,21 +652,13 @@ 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,

cgo/cgo_test.go

@@ -30,14 +30,7 @@ func normalizeResult(result string) string {
 func TestCGo(t *testing.T) {
 	var cflags = []string{"--target=armv6m-unknown-unknown-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.

cgo/libclang_config.go

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

cgo/libclang_config_llvm11.go

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

cgo/libclang_config_llvm12.go

@@ -1,16 +0,0 @@
-//go:build !byollvm && llvm12
-// +build !byollvm,llvm12
-
-package cgo
-
-/*
-#cgo linux        CFLAGS:  -I/usr/lib/llvm-12/include
-#cgo darwin amd64 CFLAGS:  -I/usr/local/opt/llvm@12/include
-#cgo darwin arm64 CFLAGS:  -I/opt/homebrew/opt/llvm@12/include
-#cgo freebsd      CFLAGS:  -I/usr/local/llvm12/include
-#cgo linux        LDFLAGS: -L/usr/lib/llvm-12/lib -lclang
-#cgo darwin amd64 LDFLAGS: -L/usr/local/opt/llvm@12/lib -lclang -lffi
-#cgo darwin arm64 LDFLAGS: -L/opt/homebrew/opt/llvm@12/lib -lclang -lffi
-#cgo freebsd      LDFLAGS: -L/usr/local/llvm12/lib -lclang
-*/
-import "C"

cgo/libclang_config_llvm13.go

@@ -1,16 +0,0 @@
-//go:build !byollvm && !llvm11 && !llvm12
-// +build !byollvm,!llvm11,!llvm12
-
-package cgo
-
-/*
-#cgo linux        CFLAGS:  -I/usr/lib/llvm-13/include
-#cgo darwin amd64 CFLAGS:  -I/usr/local/opt/llvm@13/include
-#cgo darwin arm64 CFLAGS:  -I/opt/homebrew/opt/llvm@13/include
-#cgo freebsd      CFLAGS:  -I/usr/local/llvm13/include
-#cgo linux        LDFLAGS: -L/usr/lib/llvm-13/lib -lclang
-#cgo darwin amd64 LDFLAGS: -L/usr/local/opt/llvm@13/lib -lclang -lffi
-#cgo darwin arm64 LDFLAGS: -L/opt/homebrew/opt/llvm@13/lib -lclang -lffi
-#cgo freebsd      LDFLAGS: -L/usr/local/llvm13/lib -lclang
-*/
-import "C"

cgo/testdata/basic.out.go

@@ -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

cgo/testdata/const.out.go

@@ -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
 

cgo/testdata/errors.out.go

@@ -18,26 +18,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

cgo/testdata/flags.out.go

@@ -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
 

cgo/testdata/symbols.go

@@ -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
-}

cgo/testdata/symbols.out.go

@@ -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

cgo/testdata/types.go

@@ -104,6 +104,10 @@ typedef struct {
 	unsigned char e : 3;
 	// Note that C++ allows bitfields bigger than the underlying type.
 } bitfield_t;
+
+// Function signatures.
+void variadic0();
+void variadic2(int x, int y, ...);
 */
 import "C"
 
@@ -167,3 +171,9 @@ func accessUnion() {
 	var _ *C.int = union2d.unionfield_i()
 	var _ *[2]float64 = union2d.unionfield_d()
 }
+
+// Test function signatures.
+func accessFunctions() {
+	C.variadic0()
+	C.variadic2(3, 5)
+}

cgo/testdata/types.out.go

@@ -4,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

compileopts/config.go

@@ -85,7 +85,7 @@ func (c *Config) CgoEnabled() bool {
 }
 
 // GC returns the garbage collection strategy in use on this platform. Valid
-// values are "none", "leaking", and "conservative".
+// values are "none", "leaking", "extalloc", and "conservative".
 func (c *Config) GC() string {
 	if c.Options.GC != "" {
 		return c.Options.GC
@@ -100,7 +100,7 @@ func (c *Config) GC() string {
 // that can be traced by the garbage collector.
 func (c *Config) NeedsStackObjects() bool {
 	switch c.GC() {
-	case "conservative":
+	case "conservative", "extalloc":
 		for _, tag := range c.BuildTags() {
 			if tag == "tinygo.wasm" {
 				return true
@@ -114,7 +114,7 @@ func (c *Config) NeedsStackObjects() bool {
 }
 
 // Scheduler returns the scheduler implementation. Valid values are "none",
-// "asyncify" and "tasks".
+//"coroutines" and "tasks".
 func (c *Config) Scheduler() string {
 	if c.Options.Scheduler != "" {
 		return c.Options.Scheduler
@@ -122,8 +122,8 @@ func (c *Config) Scheduler() string {
 	if c.Target.Scheduler != "" {
 		return c.Target.Scheduler
 	}
-	// Fall back to none.
-	return "none"
+	// Fall back to coroutines, which are supported everywhere.
+	return "coroutines"
 }
 
 // Serial returns the serial implementation for this build configuration: uart,
@@ -159,6 +159,31 @@ func (c *Config) OptLevels() (optLevel, sizeLevel int, inlinerThreshold uint) {
 	}
 }
 
+// FuncImplementation picks an appropriate func value implementation for the
+// target.
+func (c *Config) FuncImplementation() string {
+	switch c.Scheduler() {
+	case "tasks", "asyncify":
+		// A func value is implemented as a pair of pointers:
+		//     {context, function pointer}
+		// where the context may be a pointer to a heap-allocated struct
+		// containing the free variables, or it may be undef if the function
+		// being pointed to doesn't need a context. The function pointer is a
+		// regular function pointer.
+		return "doubleword"
+	case "none", "coroutines":
+		// As "doubleword", but with the function pointer replaced by a unique
+		// ID per function signature. Function values are called by using a
+		// switch statement and choosing which function to call.
+		// Pick the switch implementation with the coroutines scheduler, as it
+		// allows the use of blocking inside a function that is used as a func
+		// value.
+		return "switch"
+	default:
+		panic("unknown scheduler type")
+	}
+}
+
 // PanicStrategy returns the panic strategy selected for this target. Valid
 // values are "print" (print the panic value, then exit) or "trap" (issue a trap
 // instruction).
@@ -199,13 +224,8 @@ func MuslArchitecture(triple string) string {
 // a precompiled libc shipped with a TinyGo build, or a libc path in the cache
 // directory (which might not yet be built).
 func (c *Config) LibcPath(name string) (path string, precompiled bool) {
-	archname := c.Triple()
-	if c.CPU() != "" {
-		archname += "-" + c.CPU()
-	}
-
 	// Try to load a precompiled library.
-	precompiledDir := filepath.Join(goenv.Get("TINYGOROOT"), "pkg", archname, name)
+	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.
@@ -214,7 +234,13 @@ func (c *Config) LibcPath(name string) (path string, precompiled bool) {
 
 	// No precompiled library found. Determine the path name that will be used
 	// in the build cache.
-	return filepath.Join(goenv.Get("GOCACHE"), name+"-"+archname), false
+	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
@@ -231,18 +257,17 @@ func (c *Config) CFlags() []string {
 		path, _ := c.LibcPath("picolibc")
 		cflags = append(cflags,
 			"--sysroot="+path,
-			"-isystem", filepath.Join(picolibcDir, "include"),
-			"-isystem", filepath.Join(picolibcDir, "tinystdio"),
+			"-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,
-			"-nostdlibinc",
-			"-isystem", filepath.Join(path, "include"),
-			"-isystem", filepath.Join(root, "lib", "musl", "arch", arch),
-			"-isystem", filepath.Join(root, "lib", "musl", "include"),
+			"--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")
@@ -252,8 +277,8 @@ func (c *Config) CFlags() []string {
 		path, _ := c.LibcPath("mingw-w64")
 		cflags = append(cflags,
 			"--sysroot="+path,
-			"-isystem", filepath.Join(root, "lib", "mingw-w64", "mingw-w64-headers", "crt"),
-			"-isystem", filepath.Join(root, "lib", "mingw-w64", "mingw-w64-headers", "defaults", "include"),
+			"-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 "":
@@ -437,15 +462,6 @@ func (c *Config) WasmAbi() string {
 	return c.Target.WasmAbi
 }
 
-// Emulator returns the emulator target config
-func (c *Config) Emulator() []string {
-	var emulator []string
-	for _, s := range c.Target.Emulator {
-		emulator = append(emulator, strings.ReplaceAll(s, "{root}", goenv.Get("TINYGOROOT")))
-	}
-	return emulator
-}
-
 type TestConfig struct {
 	CompileTestBinary bool
 	// TODO: Filter the test functions to run, include verbose flag, etc

compileopts/options.go

@@ -7,8 +7,8 @@ import (
 )
 
 var (
-	validGCOptions            = []string{"none", "leaking", "conservative"}
-	validSchedulerOptions     = []string{"none", "tasks", "asyncify"}
+	validGCOptions            = []string{"none", "leaking", "extalloc", "conservative"}
+	validSchedulerOptions     = []string{"none", "tasks", "coroutines", "asyncify"}
 	validSerialOptions        = []string{"none", "uart", "usb"}
 	validPrintSizeOptions     = []string{"none", "short", "full"}
 	validPanicStrategyOptions = []string{"print", "trap"}
@@ -32,7 +32,7 @@ type Options struct {
 	DumpSSA         bool
 	VerifyIR        bool
 	PrintCommands   func(cmd string, args ...string)
-	Semaphore       chan struct{} // -p flag controls cap
+	Parallelism     int // -p flag
 	Debug           bool
 	PrintSizes      string
 	PrintAllocs     *regexp.Regexp // regexp string
@@ -44,7 +44,6 @@ type Options struct {
 	Programmer      string
 	OpenOCDCommands []string
 	LLVMFeatures    string
-	Directory       string
 }
 
 // Verify performs a validation on the given options, raising an error if options are not valid.

compileopts/options_test.go

@@ -9,8 +9,8 @@ import (
 
 func TestVerifyOptions(t *testing.T) {
 
-	expectedGCError := errors.New(`invalid gc option 'incorrect': valid values are none, leaking, conservative`)
-	expectedSchedulerError := errors.New(`invalid scheduler option 'incorrect': valid values are none, tasks, asyncify`)
+	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`)
 	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`)
 
@@ -42,6 +42,12 @@ func TestVerifyOptions(t *testing.T) {
 				GC: "leaking",
 			},
 		},
+		{
+			name: "GCOptionExtalloc",
+			opts: compileopts.Options{
+				GC: "extalloc",
+			},
+		},
 		{
 			name: "GCOptionConservative",
 			opts: compileopts.Options{
@@ -67,6 +73,12 @@ func TestVerifyOptions(t *testing.T) {
 				Scheduler: "tasks",
 			},
 		},
+		{
+			name: "SchedulerOptionCoroutines",
+			opts: compileopts.Options{
+				Scheduler: "coroutines",
+			},
+		},
 		{
 			name: "InvalidPrintSizeOption",
 			opts: compileopts.Options{

compileopts/target.go

@@ -12,11 +12,9 @@ import (
 	"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.
@@ -258,14 +256,13 @@ func defaultTarget(goos, goarch, triple string) (*TargetSpec, error) {
 		spec.Features = "+cx8,+fxsr,+mmx,+sse,+sse2,+x87"
 	case "arm":
 		spec.CPU = "generic"
-		spec.CFlags = append(spec.CFlags, "-fno-unwind-tables")
 		switch strings.Split(triple, "-")[0] {
 		case "armv5":
-			spec.Features = "+armv5t,+strict-align,-aes,-bf16,-d32,-dotprod,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fp64,-fpregs,-fullfp16,-mve.fp,-neon,-sha2,-thumb-mode,-vfp2,-vfp2sp,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp"
+			spec.Features = "+armv5t,+strict-align,-thumb-mode"
 		case "armv6":
-			spec.Features = "+armv6,+dsp,+fp64,+strict-align,+vfp2,+vfp2sp,-aes,-d32,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fullfp16,-neon,-sha2,-thumb-mode,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp"
+			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,-aes,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fullfp16,-sha2,-thumb-mode,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp"
+			spec.Features = "+armv7-a,+dsp,+fp64,+vfp2,+vfp2sp,+vfp3d16,+vfp3d16sp,-thumb-mode"
 		}
 	case "arm64":
 		spec.CPU = "generic"
@@ -282,12 +279,6 @@ func defaultTarget(goos, goarch, triple string) (*TargetSpec, error) {
 	} 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",
@@ -295,12 +286,6 @@ func defaultTarget(goos, goarch, triple string) (*TargetSpec, error) {
 			"--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
 	}

compiler/atomic.go

@@ -1,7 +1,6 @@
 package compiler
 
 import (
-	"fmt"
 	"strings"
 
 	"golang.org/x/tools/go/ssa"
@@ -17,20 +16,6 @@ func (b *builder) createAtomicOp(call *ssa.CallCommon) (llvm.Value, bool) {
 	case "AddInt32", "AddInt64", "AddUint32", "AddUint64", "AddUintptr":
 		ptr := b.getValue(call.Args[0])
 		val := b.getValue(call.Args[1])
-		if strings.HasPrefix(b.Triple, "avr") {
-			// AtomicRMW does not work on AVR as intended:
-			// - There are some register allocation issues (fixed by https://reviews.llvm.org/D97127 which is not yet in a usable LLVM release)
-			// - The result is the new value instead of the old value
-			vType := val.Type()
-			name := fmt.Sprintf("__sync_fetch_and_add_%d", vType.IntTypeWidth()/8)
-			fn := b.mod.NamedFunction(name)
-			if fn.IsNil() {
-				fn = llvm.AddFunction(b.mod, name, llvm.FunctionType(vType, []llvm.Type{ptr.Type(), vType}, false))
-			}
-			oldVal := b.createCall(fn, []llvm.Value{ptr, val}, "")
-			// Return the new value, not the original value returned.
-			return b.CreateAdd(oldVal, val, ""), true
-		}
 		oldVal := b.CreateAtomicRMW(llvm.AtomicRMWBinOpAdd, ptr, val, llvm.AtomicOrderingSequentiallyConsistent, true)
 		// Return the new value, not the original value returned by atomicrmw.
 		return b.CreateAdd(oldVal, val, ""), true
@@ -88,23 +73,6 @@ func (b *builder) createAtomicOp(call *ssa.CallCommon) (llvm.Value, bool) {
 	case "StoreInt32", "StoreInt64", "StoreUint32", "StoreUint64", "StoreUintptr", "StorePointer":
 		ptr := b.getValue(call.Args[0])
 		val := b.getValue(call.Args[1])
-		if strings.HasPrefix(b.Triple, "avr") {
-			// SelectionDAGBuilder is currently missing the "are unaligned atomics allowed" check for stores.
-			vType := val.Type()
-			isPointer := vType.TypeKind() == llvm.PointerTypeKind
-			if isPointer {
-				// libcalls only supports integers, so cast to an integer.
-				vType = b.uintptrType
-				val = b.CreatePtrToInt(val, vType, "")
-				ptr = b.CreateBitCast(ptr, llvm.PointerType(vType, 0), "")
-			}
-			name := fmt.Sprintf("__atomic_store_%d", vType.IntTypeWidth()/8)
-			fn := b.mod.NamedFunction(name)
-			if fn.IsNil() {
-				fn = llvm.AddFunction(b.mod, name, llvm.FunctionType(vType, []llvm.Type{ptr.Type(), vType, b.uintptrType}, false))
-			}
-			return b.createCall(fn, []llvm.Value{ptr, val, llvm.ConstInt(b.uintptrType, 5, false)}, ""), true
-		}
 		store := b.CreateStore(val, ptr)
 		store.SetOrdering(llvm.AtomicOrderingSequentiallyConsistent)
 		store.SetAlignment(b.targetData.PrefTypeAlignment(val.Type())) // required

compiler/calls.go

@@ -40,7 +40,8 @@ func (b *builder) createRuntimeCall(fnName string, args []llvm.Value, name strin
 	if llvmFn.IsNil() {
 		panic("trying to call non-existent function: " + fn.RelString(nil))
 	}
-	args = append(args, llvm.Undef(b.i8ptrType)) // unused context parameter
+	args = append(args, llvm.Undef(b.i8ptrType))            // unused context parameter
+	args = append(args, llvm.ConstPointerNull(b.i8ptrType)) // coroutine handle
 	return b.createCall(llvmFn, args, name)
 }
 

compiler/compiler.go

@@ -20,6 +20,11 @@ import (
 	"tinygo.org/x/go-llvm"
 )
 
+// 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
+
 func init() {
 	llvm.InitializeAllTargets()
 	llvm.InitializeAllTargetMCs()
@@ -47,6 +52,7 @@ type Config struct {
 
 	// Various compiler options that determine how code is generated.
 	Scheduler          string
+	FuncImplementation string
 	AutomaticStackSize bool
 	DefaultStackSize   uint64
 	NeedsStackObjects  bool
@@ -77,7 +83,6 @@ type compilerContext struct {
 	diagnostics      []error
 	astComments      map[string]*ast.CommentGroup
 	pkg              *types.Package
-	packageDir       string // directory for this package
 	runtimePkg       *types.Package
 }
 
@@ -139,8 +144,6 @@ type builder struct {
 	deferPtr          llvm.Value
 	difunc            llvm.Metadata
 	dilocals          map[*types.Var]llvm.Metadata
-	initInlinedAt     llvm.Metadata            // fake inlinedAt position
-	initPseudoFuncs   map[string]llvm.Metadata // fake "inlined" functions for proper init debug locations
 	allDeferFuncs     []interface{}
 	deferFuncs        map[*ssa.Function]int
 	deferInvokeFuncs  map[string]int
@@ -244,7 +247,6 @@ func Sizes(machine llvm.TargetMachine) types.Sizes {
 // 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.packageDir = pkg.OriginalDir()
 	c.pkg = pkg.Pkg
 	c.runtimePkg = ssaPkg.Prog.ImportedPackage("runtime").Pkg
 	c.program = ssaPkg.Prog
@@ -269,10 +271,6 @@ func CompilePackage(moduleName string, pkg *loader.Package, ssaPkg *ssa.Package,
 	// Predeclare the runtime.alloc function, which is used by the wordpack
 	// functionality.
 	c.getFunction(c.program.ImportedPackage("runtime").Members["alloc"].(*ssa.Function))
-	if c.NeedsStackObjects {
-		// Predeclare trackPointer, which is used everywhere we use runtime.alloc.
-		c.getFunction(c.program.ImportedPackage("runtime").Members["trackPointer"].(*ssa.Function))
-	}
 
 	// Compile all functions, methods, and global variables in this package.
 	irbuilder := c.ctx.NewBuilder()
@@ -603,51 +601,6 @@ func (c *compilerContext) createDIType(typ types.Type) llvm.Metadata {
 	}
 }
 
-// setDebugLocation sets the current debug location for the builder.
-func (b *builder) setDebugLocation(pos token.Pos) {
-	if pos == token.NoPos {
-		// No debug information available for this instruction.
-		b.SetCurrentDebugLocation(0, 0, b.difunc, llvm.Metadata{})
-		return
-	}
-
-	position := b.program.Fset.Position(pos)
-	if b.fn.Synthetic == "package initializer" {
-		// Package initializers are treated specially, because while individual
-		// Go SSA instructions have file/line/col information, the parent
-		// function does not. LLVM doesn't store filename information per
-		// instruction, only per function. We work around this difference by
-		// creating a fake DIFunction for each Go file and say that the
-		// instruction really came from that (fake) function but was inlined in
-		// the package initializer function.
-		position := b.program.Fset.Position(pos)
-		name := filepath.Base(position.Filename)
-		difunc, ok := b.initPseudoFuncs[name]
-		if !ok {
-			diFuncType := b.dibuilder.CreateSubroutineType(llvm.DISubroutineType{
-				File: b.getDIFile(position.Filename),
-			})
-			difunc = b.dibuilder.CreateFunction(b.getDIFile(position.Filename), llvm.DIFunction{
-				Name:         b.fn.RelString(nil) + "#" + name,
-				File:         b.getDIFile(position.Filename),
-				Line:         0,
-				Type:         diFuncType,
-				LocalToUnit:  true,
-				IsDefinition: true,
-				ScopeLine:    0,
-				Flags:        llvm.FlagPrototyped,
-				Optimized:    true,
-			})
-			b.initPseudoFuncs[name] = difunc
-		}
-		b.SetCurrentDebugLocation(uint(position.Line), uint(position.Column), difunc, b.initInlinedAt)
-		return
-	}
-
-	// Regular debug information.
-	b.SetCurrentDebugLocation(uint(position.Line), uint(position.Column), b.difunc, llvm.Metadata{})
-}
-
 // getLocalVariable returns a debug info entry for a local variable, which may
 // either be a parameter or a regular variable. It will create a new metadata
 // entry if there isn't one for the variable yet.
@@ -900,14 +853,16 @@ func (b *builder) createFunction() {
 	// Add debug info, if needed.
 	if b.Debug {
 		if b.fn.Synthetic == "package initializer" {
-			// Package initializer functions have no debug info. Create some
-			// fake debug info to at least have *something*.
-			b.difunc = b.attachDebugInfoRaw(b.fn, b.llvmFn, "", b.packageDir, 0)
+			// Package initializers have no debug info. Create some fake debug
+			// info to at least have *something*.
+			filename := b.fn.Package().Pkg.Path() + "/<init>"
+			b.difunc = b.attachDebugInfoRaw(b.fn, b.llvmFn, "", filename, 0)
 		} else if b.fn.Syntax() != nil {
 			// Create debug info file if needed.
 			b.difunc = b.attachDebugInfo(b.fn)
 		}
-		b.setDebugLocation(b.fn.Pos())
+		pos := b.program.Fset.Position(b.fn.Pos())
+		b.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), b.difunc, llvm.Metadata{})
 	}
 
 	// Pre-create all basic blocks in the function.
@@ -919,16 +874,6 @@ func (b *builder) createFunction() {
 	entryBlock := b.blockEntries[b.fn.Blocks[0]]
 	b.SetInsertPointAtEnd(entryBlock)
 
-	if b.fn.Synthetic == "package initializer" {
-		b.initPseudoFuncs = make(map[string]llvm.Metadata)
-
-		// Create a fake 'inlined at' metadata node.
-		// See setDebugLocation for details.
-		alloca := b.CreateAlloca(b.uintptrType, "")
-		b.initInlinedAt = alloca.InstructionDebugLoc()
-		alloca.EraseFromParentAsInstruction()
-	}
-
 	// Load function parameters
 	llvmParamIndex := 0
 	for _, param := range b.fn.Params {
@@ -967,7 +912,9 @@ func (b *builder) createFunction() {
 	// method).
 	var context llvm.Value
 	if !b.info.exported {
-		context = b.llvmFn.LastParam()
+		parentHandle := b.llvmFn.LastParam()
+		parentHandle.SetName("parentHandle")
+		context = llvm.PrevParam(parentHandle)
 		context.SetName("context")
 	}
 	if len(b.fn.FreeVars) != 0 {
@@ -1121,7 +1068,8 @@ func getPos(val posser) token.Pos {
 // particular Go SSA instruction.
 func (b *builder) createInstruction(instr ssa.Instruction) {
 	if b.Debug {
-		b.setDebugLocation(getPos(instr))
+		pos := b.program.Fset.Position(getPos(instr))
+		b.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), b.difunc, llvm.Metadata{})
 	}
 
 	switch instr := instr.(type) {
@@ -1503,6 +1451,9 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 		// This function takes a context parameter.
 		// Add it to the end of the parameter list.
 		params = append(params, context)
+
+		// Parent coroutine handle.
+		params = append(params, llvm.Undef(b.i8ptrType))
 	}
 
 	return b.createCall(callee, params, ""), nil
@@ -1841,7 +1792,20 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 		if expr.IsString {
 			return b.createRuntimeCall("stringNext", []llvm.Value{llvmRangeVal, it}, "range.next"), nil
 		} else { // map
-			return b.createMapIteratorNext(rangeVal, llvmRangeVal, it), nil
+			llvmKeyType := b.getLLVMType(rangeVal.Type().Underlying().(*types.Map).Key())
+			llvmValueType := b.getLLVMType(rangeVal.Type().Underlying().(*types.Map).Elem())
+
+			mapKeyAlloca, mapKeyPtr, mapKeySize := b.createTemporaryAlloca(llvmKeyType, "range.key")
+			mapValueAlloca, mapValuePtr, mapValueSize := b.createTemporaryAlloca(llvmValueType, "range.value")
+			ok := b.createRuntimeCall("hashmapNext", []llvm.Value{llvmRangeVal, it, mapKeyPtr, mapValuePtr}, "range.next")
+
+			tuple := llvm.Undef(b.ctx.StructType([]llvm.Type{b.ctx.Int1Type(), llvmKeyType, llvmValueType}, false))
+			tuple = b.CreateInsertValue(tuple, ok, 0, "")
+			tuple = b.CreateInsertValue(tuple, b.CreateLoad(mapKeyAlloca, ""), 1, "")
+			tuple = b.CreateInsertValue(tuple, b.CreateLoad(mapValueAlloca, ""), 2, "")
+			b.emitLifetimeEnd(mapKeyPtr, mapKeySize)
+			b.emitLifetimeEnd(mapValuePtr, mapValueSize)
+			return tuple, nil
 		}
 	case *ssa.Phi:
 		phi := b.CreatePHI(b.getLLVMType(expr.Type()), "")
@@ -2312,16 +2276,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())
 			}
@@ -2838,8 +2802,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)
 			}

compiler/compiler_test.go

@@ -41,13 +41,6 @@ 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", "", ""},
@@ -55,20 +48,22 @@ func TestCompiler(t *testing.T) {
 		{"string.go", "", ""},
 		{"float.go", "", ""},
 		{"interface.go", "", ""},
-		{"func.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", ""})
+
+	_, minor, err := goenv.GetGorootVersion(goenv.Get("GOROOT"))
+	if err != nil {
+		t.Fatal("could not read Go version:", err)
 	}
-	if goMinor >= 17 {
+	if minor >= 17 {
 		tests = append(tests, testCase{"go1.17.go", "", ""})
 	}
 
@@ -105,9 +100,9 @@ func TestCompiler(t *testing.T) {
 				CodeModel:          config.CodeModel(),
 				RelocationModel:    config.RelocationModel(),
 				Scheduler:          config.Scheduler(),
+				FuncImplementation: config.FuncImplementation(),
 				AutomaticStackSize: config.AutomaticStackSize(),
 				DefaultStackSize:   config.Target.DefaultStackSize,
-				NeedsStackObjects:  config.NeedsStackObjects(),
 			}
 			machine, err := NewTargetMachine(compilerConfig)
 			if err != nil {
@@ -206,12 +201,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
@@ -221,16 +210,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 and higher.
-			continue
-		}
-		if llvmVersion < 13 && strings.HasPrefix(line, "target datalayout = ") {
-			// The datalayout string may vary betewen LLVM versions.
-			// Right now test outputs are for LLVM 13 and higher.
-			continue
-		}
 		out = append(out, line)
 	}
 	return out

compiler/defer.go

@@ -343,6 +343,9 @@ func (b *builder) createRunDefers() {
 				forwardParams = append(forwardParams, llvm.Undef(b.i8ptrType))
 			}
 
+			// Parent coroutine handle.
+			forwardParams = append(forwardParams, llvm.Undef(b.i8ptrType))
+
 			b.createCall(fnPtr, forwardParams, "")
 
 		case *ssa.Function:
@@ -371,6 +374,9 @@ func (b *builder) createRunDefers() {
 				// Add the context parameter. We know it is ignored by the receiving
 				// function, but we have to pass one anyway.
 				forwardParams = append(forwardParams, llvm.Undef(b.i8ptrType))
+
+				// Parent coroutine handle.
+				forwardParams = append(forwardParams, llvm.Undef(b.i8ptrType))
 			}
 
 			// Call real function.
@@ -397,6 +403,9 @@ func (b *builder) createRunDefers() {
 				forwardParams = append(forwardParams, forwardParam)
 			}
 
+			// Parent coroutine handle.
+			forwardParams = append(forwardParams, llvm.Undef(b.i8ptrType))
+
 			// Call deferred function.
 			b.createCall(b.getFunction(fn), forwardParams, "")
 		case *ssa.Builtin:

compiler/func.go

@@ -19,8 +19,29 @@ func (b *builder) createFuncValue(funcPtr, context llvm.Value, sig *types.Signat
 // createFuncValue creates a function value from a raw function pointer with no
 // context.
 func (c *compilerContext) createFuncValue(builder llvm.Builder, funcPtr, context llvm.Value, sig *types.Signature) llvm.Value {
-	// Closure is: {context, function pointer}
-	funcValueScalar := llvm.ConstBitCast(funcPtr, c.rawVoidFuncType)
+	var funcValueScalar llvm.Value
+	switch c.FuncImplementation {
+	case "doubleword":
+		// Closure is: {context, function pointer}
+		funcValueScalar = llvm.ConstBitCast(funcPtr, c.rawVoidFuncType)
+	case "switch":
+		funcValueWithSignatureGlobalName := funcPtr.Name() + "$withSignature"
+		funcValueWithSignatureGlobal := c.mod.NamedGlobal(funcValueWithSignatureGlobalName)
+		if funcValueWithSignatureGlobal.IsNil() {
+			funcValueWithSignatureType := c.getLLVMRuntimeType("funcValueWithSignature")
+			funcValueWithSignature := llvm.ConstNamedStruct(funcValueWithSignatureType, []llvm.Value{
+				llvm.ConstPtrToInt(funcPtr, c.uintptrType),
+				c.getFuncSignatureID(sig),
+			})
+			funcValueWithSignatureGlobal = llvm.AddGlobal(c.mod, funcValueWithSignatureType, funcValueWithSignatureGlobalName)
+			funcValueWithSignatureGlobal.SetInitializer(funcValueWithSignature)
+			funcValueWithSignatureGlobal.SetGlobalConstant(true)
+			funcValueWithSignatureGlobal.SetLinkage(llvm.LinkOnceODRLinkage)
+		}
+		funcValueScalar = llvm.ConstPtrToInt(funcValueWithSignatureGlobal, c.uintptrType)
+	default:
+		panic("unimplemented func value variant")
+	}
 	funcValueType := c.getFuncType(sig)
 	funcValue := llvm.Undef(funcValueType)
 	funcValue = builder.CreateInsertValue(funcValue, context, 0, "")
@@ -57,19 +78,43 @@ func (b *builder) extractFuncContext(funcValue llvm.Value) llvm.Value {
 // value. This may be an expensive operation.
 func (b *builder) decodeFuncValue(funcValue llvm.Value, sig *types.Signature) (funcPtr, context llvm.Value) {
 	context = b.CreateExtractValue(funcValue, 0, "")
-	bitcast := b.CreateExtractValue(funcValue, 1, "")
-	if !bitcast.IsAConstantExpr().IsNil() && bitcast.Opcode() == llvm.BitCast {
-		funcPtr = bitcast.Operand(0)
-		return
+	switch b.FuncImplementation {
+	case "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, "")
+	case "switch":
+		if !funcValue.IsAConstant().IsNil() {
+			// If this is a constant func value, the underlying function is
+			// known and can be returned directly.
+			funcValueWithSignatureGlobal := llvm.ConstExtractValue(funcValue, []uint32{1}).Operand(0)
+			funcPtr = llvm.ConstExtractValue(funcValueWithSignatureGlobal.Initializer(), []uint32{0}).Operand(0)
+			return
+		}
+		llvmSig := b.getRawFuncType(sig)
+		sigGlobal := b.getFuncSignatureID(sig)
+		funcPtr = b.createRuntimeCall("getFuncPtr", []llvm.Value{funcValue, sigGlobal}, "")
+		funcPtr = b.CreateIntToPtr(funcPtr, llvmSig, "")
+	default:
+		panic("unimplemented func value variant")
 	}
-	llvmSig := b.getRawFuncType(sig)
-	funcPtr = b.CreateBitCast(bitcast, llvmSig, "")
 	return
 }
 
 // getFuncType returns the type of a func value given a signature.
 func (c *compilerContext) getFuncType(typ *types.Signature) llvm.Type {
-	return c.ctx.StructType([]llvm.Type{c.i8ptrType, c.rawVoidFuncType}, false)
+	switch c.FuncImplementation {
+	case "doubleword":
+		return c.ctx.StructType([]llvm.Type{c.i8ptrType, c.rawVoidFuncType}, false)
+	case "switch":
+		return c.getLLVMRuntimeType("funcValue")
+	default:
+		panic("unimplemented func value variant")
+	}
 }
 
 // getRawFuncType returns a LLVM function pointer type for a given signature.
@@ -115,6 +160,7 @@ func (c *compilerContext) getRawFuncType(typ *types.Signature) llvm.Type {
 	}
 	// All functions take these parameters at the end.
 	paramTypes = append(paramTypes, c.i8ptrType) // context
+	paramTypes = append(paramTypes, c.i8ptrType) // parent coroutine
 
 	// Make a func type out of the signature.
 	return llvm.PointerType(llvm.FunctionType(returnType, paramTypes, false), c.funcPtrAddrSpace)

compiler/goroutine.go

@@ -30,6 +30,11 @@ func (b *builder) createGo(instr *ssa.Go) {
 		switch value := instr.Call.Value.(type) {
 		case *ssa.Function:
 			// Goroutine call is regular function call. No context is necessary.
+			if b.Scheduler == "coroutines" {
+				// The context parameter is assumed to be always present in the
+				// coroutines scheduler.
+				context = llvm.Undef(b.i8ptrType)
+			}
 		case *ssa.MakeClosure:
 			// A goroutine call on a func value, but the callee is trivial to find. For
 			// example: immediately applied functions.
@@ -90,31 +95,50 @@ func (b *builder) createGo(instr *ssa.Go) {
 		//   * The function pointer (for tasks).
 		var context llvm.Value
 		funcPtr, context = b.decodeFuncValue(b.getValue(instr.Call.Value), instr.Call.Value.Type().Underlying().(*types.Signature))
-		params = append(params, context, funcPtr)
+		params = append(params, context) // context parameter
 		hasContext = true
+		switch b.Scheduler {
+		case "none", "coroutines":
+			// There are no additional parameters needed for the goroutine start operation.
+		case "tasks", "asyncify":
+			// Add the function pointer as a parameter to start the goroutine.
+			params = append(params, funcPtr)
+		default:
+			panic("unknown scheduler type")
+		}
 		prefix = b.fn.RelString(nil)
 	}
 
 	paramBundle := b.emitPointerPack(params)
-	var stackSize llvm.Value
-	callee := b.createGoroutineStartWrapper(funcPtr, prefix, hasContext, instr.Pos())
-	if b.AutomaticStackSize {
-		// The stack size is not known until after linking. Call a dummy
-		// function that will be replaced with a load from a special ELF
-		// section that contains the stack size (and is modified after
-		// linking).
-		stackSizeFn := b.getFunction(b.program.ImportedPackage("internal/task").Members["getGoroutineStackSize"].(*ssa.Function))
-		stackSize = b.createCall(stackSizeFn, []llvm.Value{callee, llvm.Undef(b.i8ptrType)}, "stacksize")
-	} else {
-		// The stack size is fixed at compile time. By emitting it here as a
-		// constant, it can be optimized.
-		if (b.Scheduler == "tasks" || b.Scheduler == "asyncify") && b.DefaultStackSize == 0 {
-			b.addError(instr.Pos(), "default stack size for goroutines is not set")
+	var callee, stackSize llvm.Value
+	switch b.Scheduler {
+	case "none", "tasks", "asyncify":
+		callee = b.createGoroutineStartWrapper(funcPtr, prefix, hasContext, instr.Pos())
+		if b.AutomaticStackSize {
+			// The stack size is not known until after linking. Call a dummy
+			// function that will be replaced with a load from a special ELF
+			// section that contains the stack size (and is modified after
+			// linking).
+			stackSizeFn := b.getFunction(b.program.ImportedPackage("internal/task").Members["getGoroutineStackSize"].(*ssa.Function))
+			stackSize = b.createCall(stackSizeFn, []llvm.Value{callee, llvm.Undef(b.i8ptrType), llvm.Undef(b.i8ptrType)}, "stacksize")
+		} else {
+			// The stack size is fixed at compile time. By emitting it here as a
+			// constant, it can be optimized.
+			if (b.Scheduler == "tasks" || b.Scheduler == "asyncify") && b.DefaultStackSize == 0 {
+				b.addError(instr.Pos(), "default stack size for goroutines is not set")
+			}
+			stackSize = llvm.ConstInt(b.uintptrType, b.DefaultStackSize, false)
 		}
-		stackSize = llvm.ConstInt(b.uintptrType, b.DefaultStackSize, false)
+	case "coroutines":
+		callee = b.CreatePtrToInt(funcPtr, b.uintptrType, "")
+		// There is no goroutine stack size: coroutines are used instead of
+		// stacks.
+		stackSize = llvm.Undef(b.uintptrType)
+	default:
+		panic("unreachable")
 	}
 	start := b.getFunction(b.program.ImportedPackage("internal/task").Members["start"].(*ssa.Function))
-	b.createCall(start, []llvm.Value{callee, paramBundle, stackSize, llvm.Undef(b.i8ptrType)}, "")
+	b.createCall(start, []llvm.Value{callee, paramBundle, stackSize, llvm.Undef(b.i8ptrType), llvm.ConstPointerNull(b.i8ptrType)}, "")
 }
 
 // createGoroutineStartWrapper creates a wrapper for the task-based
@@ -193,6 +217,7 @@ func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix stri
 
 		// Create the list of params for the call.
 		paramTypes := fn.Type().ElementType().ParamTypes()
+		paramTypes = paramTypes[:len(paramTypes)-1] // strip parentHandle parameter
 		if !hasContext {
 			paramTypes = paramTypes[:len(paramTypes)-1] // strip context parameter
 		}
@@ -200,13 +225,14 @@ func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix stri
 		if !hasContext {
 			params = append(params, llvm.Undef(c.i8ptrType)) // add dummy context parameter
 		}
+		params = append(params, llvm.Undef(c.i8ptrType)) // add dummy parentHandle parameter
 
 		// Create the call.
 		builder.CreateCall(fn, params, "")
 
 		if c.Scheduler == "asyncify" {
 			builder.CreateCall(deadlock, []llvm.Value{
-				llvm.Undef(c.i8ptrType),
+				llvm.Undef(c.i8ptrType), llvm.Undef(c.i8ptrType),
 			}, "")
 		}
 
@@ -262,19 +288,25 @@ func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix stri
 
 		// Get the list of parameters, with the extra parameters at the end.
 		paramTypes := fn.Type().ElementType().ParamTypes()
-		paramTypes = append(paramTypes, fn.Type()) // the last element is the function pointer
+		paramTypes[len(paramTypes)-1] = fn.Type() // the last element is the function pointer
 		params := llvmutil.EmitPointerUnpack(builder, c.mod, wrapper.Param(0), paramTypes)
 
 		// Get the function pointer.
 		fnPtr := params[len(params)-1]
-		params = params[:len(params)-1]
+
+		// The last parameter in the packed object has somewhat of a dual role.
+		// Inside the parameter bundle it's the function pointer, stored right
+		// after the context pointer. But in the IR call instruction, it's the
+		// parentHandle function that's always undef outside of the coroutines
+		// scheduler. Thus, make the parameter undef here.
+		params[len(params)-1] = llvm.Undef(c.i8ptrType)
 
 		// Create the call.
 		builder.CreateCall(fnPtr, params, "")
 
 		if c.Scheduler == "asyncify" {
 			builder.CreateCall(deadlock, []llvm.Value{
-				llvm.Undef(c.i8ptrType),
+				llvm.Undef(c.i8ptrType), llvm.Undef(c.i8ptrType),
 			}, "")
 		}
 	}

compiler/inlineasm.go

@@ -24,7 +24,7 @@ func (b *builder) createInlineAsm(args []ssa.Value) (llvm.Value, error) {
 	// Magic function: insert inline assembly instead of calling it.
 	fnType := llvm.FunctionType(b.ctx.VoidType(), []llvm.Type{}, false)
 	asm := constant.StringVal(args[0].(*ssa.Const).Value)
-	target := llvm.InlineAsm(fnType, asm, "", true, false, 0, false)
+	target := llvm.InlineAsm(fnType, asm, "", true, false, 0)
 	return b.CreateCall(target, nil, ""), nil
 }
 
@@ -116,7 +116,7 @@ func (b *builder) createInlineAsmFull(instr *ssa.CallCommon) (llvm.Value, error)
 		outputType = b.ctx.VoidType()
 	}
 	fnType := llvm.FunctionType(outputType, argTypes, false)
-	target := llvm.InlineAsm(fnType, asmString, strings.Join(constraints, ","), true, false, 0, false)
+	target := llvm.InlineAsm(fnType, asmString, strings.Join(constraints, ","), true, false, 0)
 	result := b.CreateCall(target, args, "")
 	if hasOutput {
 		return result, nil
@@ -159,7 +159,7 @@ func (b *builder) emitSVCall(args []ssa.Value) (llvm.Value, error) {
 	// marked as clobbered.
 	constraints += ",~{r1},~{r2},~{r3}"
 	fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
-	target := llvm.InlineAsm(fnType, asm, constraints, true, false, 0, false)
+	target := llvm.InlineAsm(fnType, asm, constraints, true, false, 0)
 	return b.CreateCall(target, llvmArgs, ""), nil
 }
 
@@ -197,7 +197,7 @@ func (b *builder) emitSV64Call(args []ssa.Value) (llvm.Value, error) {
 	// marked as clobbered.
 	constraints += ",~{x1},~{x2},~{x3},~{x4},~{x5},~{x6},~{x7}"
 	fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
-	target := llvm.InlineAsm(fnType, asm, constraints, true, false, 0, false)
+	target := llvm.InlineAsm(fnType, asm, constraints, true, false, 0)
 	return b.CreateCall(target, llvmArgs, ""), nil
 }
 
@@ -222,24 +222,24 @@ func (b *builder) emitCSROperation(call *ssa.CallCommon) (llvm.Value, error) {
 		// marked as such.
 		fnType := llvm.FunctionType(b.uintptrType, nil, false)
 		asm := fmt.Sprintf("csrr $0, %d", csr)
-		target := llvm.InlineAsm(fnType, asm, "=r", true, false, 0, false)
+		target := llvm.InlineAsm(fnType, asm, "=r", true, false, 0)
 		return b.CreateCall(target, nil, ""), nil
 	case "Set":
 		fnType := llvm.FunctionType(b.ctx.VoidType(), []llvm.Type{b.uintptrType}, false)
 		asm := fmt.Sprintf("csrw %d, $0", csr)
-		target := llvm.InlineAsm(fnType, asm, "r", true, false, 0, false)
+		target := llvm.InlineAsm(fnType, asm, "r", true, false, 0)
 		return b.CreateCall(target, []llvm.Value{b.getValue(call.Args[1])}, ""), nil
 	case "SetBits":
 		// Note: it may be possible to optimize this to csrrsi in many cases.
 		fnType := llvm.FunctionType(b.uintptrType, []llvm.Type{b.uintptrType}, false)
 		asm := fmt.Sprintf("csrrs $0, %d, $1", csr)
-		target := llvm.InlineAsm(fnType, asm, "=r,r", true, false, 0, false)
+		target := llvm.InlineAsm(fnType, asm, "=r,r", true, false, 0)
 		return b.CreateCall(target, []llvm.Value{b.getValue(call.Args[1])}, ""), nil
 	case "ClearBits":
 		// Note: it may be possible to optimize this to csrrci in many cases.
 		fnType := llvm.FunctionType(b.uintptrType, []llvm.Type{b.uintptrType}, false)
 		asm := fmt.Sprintf("csrrc $0, %d, $1", csr)
-		target := llvm.InlineAsm(fnType, asm, "=r,r", true, false, 0, false)
+		target := llvm.InlineAsm(fnType, asm, "=r,r", true, false, 0)
 		return b.CreateCall(target, []llvm.Value{b.getValue(call.Args[1])}, ""), nil
 	default:
 		return llvm.Value{}, b.makeError(call.Pos(), "unknown CSR operation: "+name)

compiler/interface.go

@@ -31,15 +31,6 @@ func (b *builder) createMakeInterface(val llvm.Value, typ types.Type, pos token.
 	return itf
 }
 
-// extractValueFromInterface extract the value from an interface value
-// (runtime._interface) under the assumption that it is of the type given in
-// llvmType. The behavior is undefied if the interface is nil or llvmType
-// doesn't match the underlying type of the interface.
-func (b *builder) extractValueFromInterface(itf llvm.Value, llvmType llvm.Type) llvm.Value {
-	valuePtr := b.CreateExtractValue(itf, 1, "typeassert.value.ptr")
-	return b.emitPointerUnpack(valuePtr, []llvm.Type{llvmType})[0]
-}
-
 // getTypeCode returns a reference to a type code.
 // It returns a pointer to an external global which should be replaced with the
 // real type in the interface lowering pass.
@@ -425,7 +416,8 @@ func (b *builder) createTypeAssert(expr *ssa.TypeAssert) llvm.Value {
 	} else {
 		// Type assert on concrete type. Extract the underlying type from
 		// the interface (but only after checking it matches).
-		valueOk = b.extractValueFromInterface(itf, assertedType)
+		valuePtr := b.CreateExtractValue(itf, 1, "typeassert.value.ptr")
+		valueOk = b.emitPointerUnpack(valuePtr, []llvm.Type{assertedType})[0]
 	}
 	b.CreateBr(nextBlock)
 
@@ -530,6 +522,7 @@ func (c *compilerContext) getInterfaceInvokeWrapper(fn *ssa.Function, llvmFn llv
 	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)
 	wrapper.SetUnnamedAddr(true)

compiler/llvm.go

@@ -147,7 +147,7 @@ func (c *compilerContext) createObjectLayout(t llvm.Type, pos token.Pos) llvm.Va
 
 	// Create the global initializer.
 	bitmapBytes := make([]byte, int(objectSizeWords+7)/8)
-	bitmap.FillBytes(bitmapBytes)
+	copy(bitmapBytes, bitmap.Bytes())
 	var bitmapByteValues []llvm.Value
 	for _, b := range bitmapBytes {
 		bitmapByteValues = append(bitmapByteValues, llvm.ConstInt(c.ctx.Int8Type(), uint64(b), false))

compiler/llvmutil/wordpack.go

@@ -97,13 +97,15 @@ func EmitPointerPack(builder llvm.Builder, mod llvm.Module, prefix string, needs
 		packedHeapAlloc := builder.CreateCall(alloc, []llvm.Value{
 			sizeValue,
 			llvm.ConstNull(i8ptrType),
-			llvm.Undef(i8ptrType), // unused context parameter
+			llvm.Undef(i8ptrType),            // unused context parameter
+			llvm.ConstPointerNull(i8ptrType), // coroutine handle
 		}, "")
 		if needsStackObjects {
 			trackPointer := mod.NamedFunction("runtime.trackPointer")
 			builder.CreateCall(trackPointer, []llvm.Value{
 				packedHeapAlloc,
-				llvm.Undef(i8ptrType), // unused context parameter
+				llvm.Undef(i8ptrType),            // unused context parameter
+				llvm.ConstPointerNull(i8ptrType), // coroutine handle
 			}, "")
 		}
 		packedAlloc := builder.CreateBitCast(packedHeapAlloc, llvm.PointerType(packedType, 0), "")

compiler/map.go

@@ -167,66 +167,6 @@ func (b *builder) createMapDelete(keyType types.Type, m, key llvm.Value, pos tok
 	}
 }
 
-// createMapIteratorNext lowers the *ssa.Next instruction for iterating over a
-// map. It returns a tuple of {bool, key, value} with the result of the
-// iteration.
-func (b *builder) createMapIteratorNext(rangeVal ssa.Value, llvmRangeVal, it llvm.Value) llvm.Value {
-	// Determine the type of the values to return from the *ssa.Next
-	// instruction. It is returned as {bool, keyType, valueType}.
-	keyType := rangeVal.Type().Underlying().(*types.Map).Key()
-	valueType := rangeVal.Type().Underlying().(*types.Map).Elem()
-	llvmKeyType := b.getLLVMType(keyType)
-	llvmValueType := b.getLLVMType(valueType)
-
-	// There is a special case in which keys are stored as an interface value
-	// instead of the value they normally are. This happens for non-trivially
-	// comparable types such as float32 or some structs.
-	isKeyStoredAsInterface := false
-	if t, ok := keyType.Underlying().(*types.Basic); ok && t.Info()&types.IsString != 0 {
-		// key is a string
-	} else if hashmapIsBinaryKey(keyType) {
-		// key can be compared with runtime.memequal
-	} else {
-		// The key is stored as an interface value, and may or may not be an
-		// interface type (for example, float32 keys are stored as an interface
-		// value).
-		if _, ok := keyType.Underlying().(*types.Interface); !ok {
-			isKeyStoredAsInterface = true
-		}
-	}
-
-	// Determine the type of the key as stored in the map.
-	llvmStoredKeyType := llvmKeyType
-	if isKeyStoredAsInterface {
-		llvmStoredKeyType = b.getLLVMRuntimeType("_interface")
-	}
-
-	// Extract the key and value from the map.
-	mapKeyAlloca, mapKeyPtr, mapKeySize := b.createTemporaryAlloca(llvmStoredKeyType, "range.key")
-	mapValueAlloca, mapValuePtr, mapValueSize := b.createTemporaryAlloca(llvmValueType, "range.value")
-	ok := b.createRuntimeCall("hashmapNext", []llvm.Value{llvmRangeVal, it, mapKeyPtr, mapValuePtr}, "range.next")
-	mapKey := b.CreateLoad(mapKeyAlloca, "")
-	mapValue := b.CreateLoad(mapValueAlloca, "")
-
-	if isKeyStoredAsInterface {
-		// The key is stored as an interface but it isn't of interface type.
-		// Extract the underlying value.
-		mapKey = b.extractValueFromInterface(mapKey, llvmKeyType)
-	}
-
-	// End the lifetimes of the allocas, because we're done with them.
-	b.emitLifetimeEnd(mapKeyPtr, mapKeySize)
-	b.emitLifetimeEnd(mapValuePtr, mapValueSize)
-
-	// Construct the *ssa.Next return value: {ok, mapKey, mapValue}
-	tuple := llvm.Undef(b.ctx.StructType([]llvm.Type{b.ctx.Int1Type(), llvmKeyType, llvmValueType}, false))
-	tuple = b.CreateInsertValue(tuple, ok, 0, "")
-	tuple = b.CreateInsertValue(tuple, mapKey, 1, "")
-	tuple = b.CreateInsertValue(tuple, mapValue, 2, "")
-
-	return tuple
-}
-
 // Returns true if this key type does not contain strings, interfaces etc., so
 // can be compared with runtime.memequal.
 func hashmapIsBinaryKey(keyType types.Type) bool {

compiler/symbol.go

@@ -84,6 +84,7 @@ func (c *compilerContext) getFunction(fn *ssa.Function) llvm.Value {
 	// closures and bound methods, but should be optimized away when not used.
 	if !info.exported {
 		paramInfos = append(paramInfos, paramInfo{llvmType: c.i8ptrType, name: "context", flags: 0})
+		paramInfos = append(paramInfos, paramInfo{llvmType: c.i8ptrType, name: "parentHandle", flags: 0})
 	}
 
 	var paramTypes []llvm.Type
@@ -207,9 +208,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)
@@ -454,14 +460,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
 }

compiler/syscall.go

@@ -56,7 +56,7 @@ func (b *builder) createRawSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		}
 		constraints += ",~{rcx},~{r11}"
 		fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
-		target := llvm.InlineAsm(fnType, "syscall", constraints, true, false, llvm.InlineAsmDialectIntel, false)
+		target := llvm.InlineAsm(fnType, "syscall", constraints, true, false, llvm.InlineAsmDialectIntel)
 		return b.CreateCall(target, args, ""), nil
 	case b.GOARCH == "386" && b.GOOS == "linux":
 		// Sources:
@@ -82,7 +82,7 @@ func (b *builder) createRawSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 			argTypes = append(argTypes, llvmValue.Type())
 		}
 		fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
-		target := llvm.InlineAsm(fnType, "int 0x80", constraints, true, false, llvm.InlineAsmDialectIntel, false)
+		target := llvm.InlineAsm(fnType, "int 0x80", constraints, true, false, llvm.InlineAsmDialectIntel)
 		return b.CreateCall(target, args, ""), nil
 	case b.GOARCH == "arm" && b.GOOS == "linux":
 		// Implement the EABI system call convention for Linux.
@@ -114,7 +114,7 @@ func (b *builder) createRawSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 			constraints += ",~{r" + strconv.Itoa(i) + "}"
 		}
 		fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
-		target := llvm.InlineAsm(fnType, "svc #0", constraints, true, false, 0, false)
+		target := llvm.InlineAsm(fnType, "svc #0", constraints, true, false, 0)
 		return b.CreateCall(target, args, ""), nil
 	case b.GOARCH == "arm64" && b.GOOS == "linux":
 		// Source: syscall(2) man page.
@@ -146,7 +146,7 @@ func (b *builder) createRawSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		}
 		constraints += ",~{x16},~{x17}" // scratch registers
 		fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
-		target := llvm.InlineAsm(fnType, "svc #0", constraints, true, false, 0, false)
+		target := llvm.InlineAsm(fnType, "svc #0", constraints, true, false, 0)
 		return b.CreateCall(target, args, ""), nil
 	default:
 		return llvm.Value{}, b.makeError(call.Pos(), "unknown GOOS/GOARCH for syscall: "+b.GOOS+"/"+b.GOARCH)
@@ -157,7 +157,7 @@ func (b *builder) createRawSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 // functions, depending on the target OS/arch.
 func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 	switch b.GOOS {
-	case "linux":
+	case "linux", "freebsd":
 		syscallResult, err := b.createRawSyscall(call)
 		if err != nil {
 			return syscallResult, err

compiler/testdata/basic.ll

@@ -1,43 +1,41 @@
 ; ModuleID = 'basic.go'
 source_filename = "basic.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128-ni:1:10:20"
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-wasi"
 
 %main.kv = type { float }
 %main.kv.0 = type { i8 }
 
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
-
-declare void @runtime.trackPointer(i8* nocapture readonly, i8*)
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
 
 ; Function Attrs: nounwind
-define hidden void @main.init(i8* %context) unnamed_addr #0 {
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.addInt(i32 %x, i32 %y, i8* %context) unnamed_addr #0 {
+define hidden i32 @main.addInt(i32 %x, i32 %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   %0 = add i32 %x, %y
   ret i32 %0
 }
 
 ; Function Attrs: nounwind
-define hidden i1 @main.equalInt(i32 %x, i32 %y, i8* %context) unnamed_addr #0 {
+define hidden i1 @main.equalInt(i32 %x, i32 %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   %0 = icmp eq i32 %x, %y
   ret i1 %0
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.divInt(i32 %x, i32 %y, i8* %context) unnamed_addr #0 {
+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) #0
+  call void @runtime.divideByZeroPanic(i8* undef, i8* null) #0
   unreachable
 
 divbyzero.next:                                   ; preds = %entry
@@ -49,16 +47,16 @@ divbyzero.next:                                   ; preds = %entry
   ret i32 %5
 }
 
-declare void @runtime.divideByZeroPanic(i8*)
+declare void @runtime.divideByZeroPanic(i8*, i8*)
 
 ; Function Attrs: nounwind
-define hidden i32 @main.divUint(i32 %x, i32 %y, i8* %context) unnamed_addr #0 {
+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) #0
+  call void @runtime.divideByZeroPanic(i8* undef, i8* null) #0
   unreachable
 
 divbyzero.next:                                   ; preds = %entry
@@ -67,13 +65,13 @@ divbyzero.next:                                   ; preds = %entry
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.remInt(i32 %x, i32 %y, i8* %context) unnamed_addr #0 {
+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) #0
+  call void @runtime.divideByZeroPanic(i8* undef, i8* null) #0
   unreachable
 
 divbyzero.next:                                   ; preds = %entry
@@ -86,13 +84,13 @@ divbyzero.next:                                   ; preds = %entry
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.remUint(i32 %x, i32 %y, i8* %context) unnamed_addr #0 {
+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) #0
+  call void @runtime.divideByZeroPanic(i8* undef, i8* null) #0
   unreachable
 
 divbyzero.next:                                   ; preds = %entry
@@ -101,61 +99,61 @@ divbyzero.next:                                   ; preds = %entry
 }
 
 ; Function Attrs: nounwind
-define hidden i1 @main.floatEQ(float %x, float %y, i8* %context) unnamed_addr #0 {
+define hidden i1 @main.floatEQ(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   %0 = fcmp oeq float %x, %y
   ret i1 %0
 }
 
 ; Function Attrs: nounwind
-define hidden i1 @main.floatNE(float %x, float %y, i8* %context) unnamed_addr #0 {
+define hidden i1 @main.floatNE(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   %0 = fcmp une float %x, %y
   ret i1 %0
 }
 
 ; Function Attrs: nounwind
-define hidden i1 @main.floatLower(float %x, float %y, i8* %context) unnamed_addr #0 {
+define hidden i1 @main.floatLower(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   %0 = fcmp olt float %x, %y
   ret i1 %0
 }
 
 ; Function Attrs: nounwind
-define hidden i1 @main.floatLowerEqual(float %x, float %y, i8* %context) unnamed_addr #0 {
+define hidden i1 @main.floatLowerEqual(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   %0 = fcmp ole float %x, %y
   ret i1 %0
 }
 
 ; Function Attrs: nounwind
-define hidden i1 @main.floatGreater(float %x, float %y, i8* %context) unnamed_addr #0 {
+define hidden i1 @main.floatGreater(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   %0 = fcmp ogt float %x, %y
   ret i1 %0
 }
 
 ; Function Attrs: nounwind
-define hidden i1 @main.floatGreaterEqual(float %x, float %y, i8* %context) unnamed_addr #0 {
+define hidden i1 @main.floatGreaterEqual(float %x, float %y, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   %0 = fcmp oge float %x, %y
   ret i1 %0
 }
 
 ; Function Attrs: nounwind
-define hidden float @main.complexReal(float %x.r, float %x.i, i8* %context) unnamed_addr #0 {
+define hidden float @main.complexReal(float %x.r, float %x.i, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   ret float %x.r
 }
 
 ; Function Attrs: nounwind
-define hidden float @main.complexImag(float %x.r, float %x.i, i8* %context) unnamed_addr #0 {
+define hidden float @main.complexImag(float %x.r, float %x.i, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   ret float %x.i
 }
 
 ; Function Attrs: nounwind
-define hidden { float, float } @main.complexAdd(float %x.r, float %x.i, float %y.r, float %y.i, i8* %context) 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 #0 {
 entry:
   %0 = fadd float %x.r, %y.r
   %1 = fadd float %x.i, %y.i
@@ -165,7 +163,7 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden { float, float } @main.complexSub(float %x.r, float %x.i, float %y.r, float %y.i, i8* %context) unnamed_addr #0 {
+define hidden { float, float } @main.complexSub(float %x.r, float %x.i, float %y.r, float %y.i, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   %0 = fsub float %x.r, %y.r
   %1 = fsub float %x.i, %y.i
@@ -175,7 +173,7 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden { float, float } @main.complexMul(float %x.r, float %x.i, float %y.r, float %y.i, i8* %context) unnamed_addr #0 {
+define hidden { float, float } @main.complexMul(float %x.r, float %x.i, float %y.r, float %y.i, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   %0 = fmul float %x.r, %y.r
   %1 = fmul float %x.i, %y.i
@@ -189,14 +187,14 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.foo(%main.kv* dereferenceable_or_null(4) %a, i8* %context) unnamed_addr #0 {
+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)
+  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) unnamed_addr #0 {
+define hidden void @"main.foo$1"(%main.kv.0* dereferenceable_or_null(1) %b, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   ret void
 }

compiler/testdata/channel.ll

@@ -1,28 +1,25 @@
 ; ModuleID = 'channel.go'
 source_filename = "channel.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128-ni:1:10:20"
+target 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.gcData", %"internal/task.state" }
-%"internal/task.gcData" = type { i8* }
+%"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*)
-
-declare void @runtime.trackPointer(i8* nocapture readonly, i8*)
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
 
 ; Function Attrs: nounwind
-define hidden void @main.init(i8* %context) unnamed_addr #0 {
+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) unnamed_addr #0 {
+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
@@ -31,22 +28,22 @@ entry:
   store i32 3, i32* %chan.value, align 4
   %chan.blockedList.bitcast = bitcast %runtime.channelBlockedList* %chan.blockedList to i8*
   call void @llvm.lifetime.start.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
-  call void @runtime.chanSend(%runtime.channel* %ch, i8* nonnull %chan.value.bitcast, %runtime.channelBlockedList* nonnull %chan.blockedList, i8* undef) #0
+  call void @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
+; Function Attrs: argmemonly nounwind willreturn
 declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture) #1
 
-declare void @runtime.chanSend(%runtime.channel* dereferenceable_or_null(32), i8*, %runtime.channelBlockedList* dereferenceable_or_null(24), i8*)
+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
+; Function Attrs: argmemonly nounwind willreturn
 declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture) #1
 
 ; Function Attrs: nounwind
-define hidden void @main.chanIntRecv(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context) unnamed_addr #0 {
+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
@@ -54,41 +51,38 @@ entry:
   call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull %chan.value.bitcast)
   %chan.blockedList.bitcast = bitcast %runtime.channelBlockedList* %chan.blockedList to i8*
   call void @llvm.lifetime.start.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
-  %0 = call i1 @runtime.chanRecv(%runtime.channel* %ch, i8* nonnull %chan.value.bitcast, %runtime.channelBlockedList* nonnull %chan.blockedList, i8* undef) #0
+  %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*)
+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) unnamed_addr #0 {
+define hidden void @main.chanZeroSend(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
-  %complit = alloca {}, align 8
   %chan.blockedList = alloca %runtime.channelBlockedList, align 8
-  %0 = bitcast {}* %complit to i8*
-  call void @runtime.trackPointer(i8* nonnull %0, i8* undef) #0
   %chan.blockedList.bitcast = bitcast %runtime.channelBlockedList* %chan.blockedList to i8*
   call void @llvm.lifetime.start.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
-  call void @runtime.chanSend(%runtime.channel* %ch, i8* null, %runtime.channelBlockedList* nonnull %chan.blockedList, i8* undef) #0
+  call void @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) unnamed_addr #0 {
+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) #0
+  %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) unnamed_addr #0 {
+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
@@ -105,7 +99,7 @@ entry:
   %.repack4 = getelementptr inbounds [2 x %runtime.chanSelectState], [2 x %runtime.chanSelectState]* %select.states.alloca, i32 0, i32 1, i32 1
   store i8* null, i8** %.repack4, align 4
   %select.states = getelementptr inbounds [2 x %runtime.chanSelectState], [2 x %runtime.chanSelectState]* %select.states.alloca, i32 0, i32 0
-  %select.result = call { i32, i1 } @runtime.tryChanSelect(i8* undef, %runtime.chanSelectState* nonnull %select.states, i32 2, i32 2, i8* undef) #0
+  %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
@@ -122,7 +116,7 @@ select.body:                                      ; preds = %select.next
   br label %select.done
 }
 
-declare { i32, i1 } @runtime.tryChanSelect(i8*, %runtime.chanSelectState*, i32, i32, i8*)
+declare { i32, i1 } @runtime.tryChanSelect(i8*, %runtime.chanSelectState*, i32, i32, i8*, i8*)
 
 attributes #0 = { nounwind }
-attributes #1 = { argmemonly nofree nosync nounwind willreturn }
+attributes #1 = { argmemonly nounwind willreturn }

compiler/testdata/float.ll

@@ -1,20 +1,18 @@
 ; ModuleID = 'float.go'
 source_filename = "float.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128-ni:1:10:20"
+target 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*)
-
-declare void @runtime.trackPointer(i8* nocapture readonly, i8*)
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
 
 ; Function Attrs: nounwind
-define hidden void @main.init(i8* %context) unnamed_addr #0 {
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.f32tou32(float %v, i8* %context) unnamed_addr #0 {
+define hidden i32 @main.f32tou32(float %v, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   %positive = fcmp oge float %v, 0.000000e+00
   %withinmax = fcmp ole float %v, 0x41EFFFFFC0000000
@@ -26,25 +24,25 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden float @main.maxu32f(i8* %context) unnamed_addr #0 {
+define hidden float @main.maxu32f(i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   ret float 0x41F0000000000000
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.maxu32tof32(i8* %context) unnamed_addr #0 {
+define hidden i32 @main.maxu32tof32(i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   ret i32 -1
 }
 
 ; Function Attrs: nounwind
-define hidden { i32, i32, i32, i32 } @main.inftoi32(i8* %context) unnamed_addr #0 {
+define hidden { i32, i32, i32, i32 } @main.inftoi32(i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   ret { i32, i32, i32, i32 } { i32 -1, i32 0, i32 2147483647, i32 -2147483648 }
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.u32tof32tou32(i32 %v, i8* %context) unnamed_addr #0 {
+define hidden i32 @main.u32tof32tou32(i32 %v, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   %0 = uitofp i32 %v to float
   %withinmax = fcmp ole float %0, 0x41EFFFFFC0000000
@@ -54,7 +52,7 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden float @main.f32tou32tof32(float %v, i8* %context) unnamed_addr #0 {
+define hidden float @main.f32tou32tof32(float %v, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   %positive = fcmp oge float %v, 0.000000e+00
   %withinmax = fcmp ole float %v, 0x41EFFFFFC0000000
@@ -67,7 +65,7 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden i8 @main.f32tou8(float %v, i8* %context) unnamed_addr #0 {
+define hidden i8 @main.f32tou8(float %v, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   %positive = fcmp oge float %v, 0.000000e+00
   %withinmax = fcmp ole float %v, 2.550000e+02
@@ -79,7 +77,7 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden i8 @main.f32toi8(float %v, i8* %context) unnamed_addr #0 {
+define hidden i8 @main.f32toi8(float %v, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   %abovemin = fcmp oge float %v, -1.280000e+02
   %belowmax = fcmp ole float %v, 1.270000e+02

compiler/testdata/func-coroutines.ll

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

compiler/testdata/func.ll

@@ -1,47 +0,0 @@
-; ModuleID = 'func.go'
-source_filename = "func.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128-ni:1:10:20"
-target triple = "wasm32-unknown-wasi"
-
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
-
-declare void @runtime.trackPointer(i8* nocapture readonly, i8*)
-
-; Function Attrs: nounwind
-define hidden void @main.init(i8* %context) unnamed_addr #0 {
-entry:
-  ret void
-}
-
-; Function Attrs: nounwind
-define hidden void @main.foo(i8* %callback.context, void ()* %callback.funcptr, i8* %context) unnamed_addr #0 {
-entry:
-  %0 = icmp eq void ()* %callback.funcptr, null
-  br i1 %0, label %fpcall.throw, label %fpcall.next
-
-fpcall.throw:                                     ; preds = %entry
-  call void @runtime.nilPanic(i8* undef) #0
-  unreachable
-
-fpcall.next:                                      ; preds = %entry
-  %1 = bitcast void ()* %callback.funcptr to void (i32, i8*)*
-  call void %1(i32 3, i8* %callback.context) #0
-  ret void
-}
-
-declare void @runtime.nilPanic(i8*)
-
-; Function Attrs: nounwind
-define hidden void @main.bar(i8* %context) unnamed_addr #0 {
-entry:
-  call void @main.foo(i8* undef, void ()* bitcast (void (i32, i8*)* @main.someFunc to void ()*), i8* undef)
-  ret void
-}
-
-; Function Attrs: nounwind
-define hidden void @main.someFunc(i32 %arg0, i8* %context) unnamed_addr #0 {
-entry:
-  ret void
-}
-
-attributes #0 = { nounwind }

compiler/testdata/gc.go

@@ -20,10 +20,6 @@ var (
 		y [60]uintptr
 		z *byte
 	}
-	struct4 *struct {
-		x *byte
-		y [61]uintptr
-	}
 
 	slice1 []byte
 	slice2 []*int
@@ -54,13 +50,14 @@ func newStruct() {
 		y [60]uintptr
 		z *byte
 	})
-	struct4 = new(struct {
-		x *byte
-		y [61]uintptr
-	})
 }
 
 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())
 }
 

compiler/testdata/gc.ll

@@ -1,6 +1,6 @@
 ; ModuleID = 'gc.go'
 source_filename = "gc.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128-ni:1:10:20"
+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 }
@@ -17,100 +17,79 @@ target triple = "wasm32-unknown-wasi"
 @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.struct4 = hidden global { i8*, [61 x i32] }* 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" }
-@"runtime/gc.layout:62-0001" = linkonce_odr unnamed_addr constant { i32, [8 x i8] } { i32 62, [8 x i8] c"\00\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*)
-
-declare void @runtime.trackPointer(i8* nocapture readonly, i8*)
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
 
 ; Function Attrs: nounwind
-define hidden void @main.init(i8* %context) unnamed_addr #0 {
+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) unnamed_addr #0 {
+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) #0
-  call void @runtime.trackPointer(i8* nonnull %new, i8* undef) #0
+  %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) #0
-  call void @runtime.trackPointer(i8* nonnull %new1, i8* undef) #0
+  %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) #0
-  call void @runtime.trackPointer(i8* nonnull %new2, i8* undef) #0
+  %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) #0
-  call void @runtime.trackPointer(i8* nonnull %new3, i8* undef) #0
+  %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) unnamed_addr #0 {
+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) #0
-  call void @runtime.trackPointer(i8* nonnull %new, i8* undef) #0
+  %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) #0
-  call void @runtime.trackPointer(i8* nonnull %new1, i8* undef) #0
+  %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) #0
-  call void @runtime.trackPointer(i8* nonnull %new2, i8* undef) #0
+  %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) unnamed_addr #0 {
+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) #0
-  call void @runtime.trackPointer(i8* nonnull %new, i8* undef) #0
+  %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) #0
-  call void @runtime.trackPointer(i8* nonnull %new1, i8* undef) #0
+  %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) #0
-  call void @runtime.trackPointer(i8* nonnull %new2, i8* undef) #0
+  %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
-  %new3 = call i8* @runtime.alloc(i32 248, i8* bitcast ({ i32, [8 x i8] }* @"runtime/gc.layout:62-0001" to i8*), i8* undef) #0
-  call void @runtime.trackPointer(i8* nonnull %new3, i8* undef) #0
-  store i8* %new3, i8** bitcast ({ i8*, [61 x i32] }** @main.struct4 to i8**), align 4
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden { i8*, void ()* }* @main.newFuncValue(i8* %context) unnamed_addr #0 {
+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) #0
+  %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 ()* }*
-  call void @runtime.trackPointer(i8* nonnull %new, i8* undef) #0
   ret { i8*, void ()* }* %0
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.makeSlice(i8* %context) unnamed_addr #0 {
+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) #0
-  call void @runtime.trackPointer(i8* nonnull %makeslice, i8* undef) #0
+  %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) #0
-  call void @runtime.trackPointer(i8* nonnull %makeslice1, i8* undef) #0
+  %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) #0
-  call void @runtime.trackPointer(i8* nonnull %makeslice3, i8* undef) #0
+  %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
@@ -118,17 +97,15 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden %runtime._interface @main.makeInterface(double %v.r, double %v.i, i8* %context) unnamed_addr #0 {
+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) #0
-  call void @runtime.trackPointer(i8* nonnull %0, i8* undef) #0
+  %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
-  call void @runtime.trackPointer(i8* nonnull %0, i8* undef) #0
   ret %runtime._interface %2
 }
 

compiler/testdata/go1.17.ll

@@ -1,43 +1,39 @@
 ; ModuleID = 'go1.17.go'
 source_filename = "go1.17.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128-ni:1:10:20"
+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*)
-
-declare void @runtime.trackPointer(i8* nocapture readonly, i8*)
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
 
 ; Function Attrs: nounwind
-define hidden void @main.init(i8* %context) unnamed_addr #0 {
+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) unnamed_addr #0 {
+define hidden i8* @main.Add32(i8* %p, i32 %len, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   %0 = getelementptr i8, i8* %p, i32 %len
-  call void @runtime.trackPointer(i8* %0, i8* undef) #0
   ret i8* %0
 }
 
 ; Function Attrs: nounwind
-define hidden i8* @main.Add64(i8* %p, i64 %len, i8* %context) unnamed_addr #0 {
+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
-  call void @runtime.trackPointer(i8* %1, i8* undef) #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) unnamed_addr #0 {
+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) #0
+  call void @runtime.sliceToArrayPointerPanic(i8* undef, i8* null) #0
   unreachable
 
 slicetoarray.next:                                ; preds = %entry
@@ -45,13 +41,12 @@ slicetoarray.next:                                ; preds = %entry
   ret [4 x i32]* %1
 }
 
-declare void @runtime.sliceToArrayPointerPanic(i8*)
+declare void @runtime.sliceToArrayPointerPanic(i8*, i8*)
 
 ; Function Attrs: nounwind
-define hidden [4 x i32]* @main.SliceToArrayConst(i8* %context) unnamed_addr #0 {
+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) #0
-  call void @runtime.trackPointer(i8* nonnull %makeslice, i8* undef) #0
+  %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
@@ -63,7 +58,7 @@ slicetoarray.next:                                ; preds = %entry
 }
 
 ; Function Attrs: nounwind
-define hidden { i32*, i32, i32 } @main.SliceInt(i32* dereferenceable_or_null(4) %ptr, i32 %len, i8* %context) unnamed_addr #0 {
+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
@@ -73,22 +68,20 @@ entry:
   br i1 %4, label %unsafe.Slice.throw, label %unsafe.Slice.next
 
 unsafe.Slice.throw:                               ; preds = %entry
-  call void @runtime.unsafeSlicePanic(i8* undef) #0
+  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
-  %8 = bitcast i32* %ptr to i8*
-  call void @runtime.trackPointer(i8* %8, i8* undef) #0
   ret { i32*, i32, i32 } %7
 }
 
-declare void @runtime.unsafeSlicePanic(i8*)
+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) unnamed_addr #0 {
+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
@@ -96,7 +89,7 @@ entry:
   br i1 %2, label %unsafe.Slice.throw, label %unsafe.Slice.next
 
 unsafe.Slice.throw:                               ; preds = %entry
-  call void @runtime.unsafeSlicePanic(i8* undef) #0
+  call void @runtime.unsafeSlicePanic(i8* undef, i8* null) #0
   unreachable
 
 unsafe.Slice.next:                                ; preds = %entry
@@ -104,12 +97,11 @@ unsafe.Slice.next:                                ; preds = %entry
   %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
-  call void @runtime.trackPointer(i8* %ptr, i8* undef) #0
   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) unnamed_addr #0 {
+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
@@ -119,7 +111,7 @@ entry:
   br i1 %4, label %unsafe.Slice.throw, label %unsafe.Slice.next
 
 unsafe.Slice.throw:                               ; preds = %entry
-  call void @runtime.unsafeSlicePanic(i8* undef) #0
+  call void @runtime.unsafeSlicePanic(i8* undef, i8* null) #0
   unreachable
 
 unsafe.Slice.next:                                ; preds = %entry
@@ -127,13 +119,11 @@ unsafe.Slice.next:                                ; preds = %entry
   %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
-  %9 = bitcast i32* %ptr to i8*
-  call void @runtime.trackPointer(i8* %9, i8* undef) #0
   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) unnamed_addr #0 {
+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
@@ -143,7 +133,7 @@ entry:
   br i1 %4, label %unsafe.Slice.throw, label %unsafe.Slice.next
 
 unsafe.Slice.throw:                               ; preds = %entry
-  call void @runtime.unsafeSlicePanic(i8* undef) #0
+  call void @runtime.unsafeSlicePanic(i8* undef, i8* null) #0
   unreachable
 
 unsafe.Slice.next:                                ; preds = %entry
@@ -151,8 +141,6 @@ unsafe.Slice.next:                                ; preds = %entry
   %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
-  %9 = bitcast i32* %ptr to i8*
-  call void @runtime.trackPointer(i8* %9, i8* undef) #0
   ret { i32*, i32, i32 } %8
 }
 

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

@@ -5,53 +5,52 @@ target triple = "thumbv7m-unknown-unknown-eabi"
 
 %runtime.channel = type { i32, i32, i8, %runtime.channelBlockedList*, i32, i32, i32, i8* }
 %runtime.channelBlockedList = type { %runtime.channelBlockedList*, %"internal/task.Task"*, %runtime.chanSelectState*, { %runtime.channelBlockedList*, i32, i32 } }
-%"internal/task.Task" = type { %"internal/task.Task"*, i8*, i64, %"internal/task.gcData", %"internal/task.state" }
-%"internal/task.gcData" = type {}
+%"internal/task.Task" = type { %"internal/task.Task"*, i8*, i64, %"internal/task.state" }
 %"internal/task.state" = type { i32, i32* }
 %runtime.chanSelectState = type { %runtime.channel*, i8* }
 
 @"main$string" = internal unnamed_addr constant [4 x i8] c"test", align 1
 
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
 
 ; Function Attrs: nounwind
-define hidden void @main.init(i8* %context) unnamed_addr #0 {
+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) unnamed_addr #0 {
+define hidden void @main.regularFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
-  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @"main.regularFunction$gowrapper" to i32), i8* undef) #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) #0
+  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @"main.regularFunction$gowrapper" to i32), i8* undef, i8* undef) #0
+  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"main.regularFunction$gowrapper" to i32), i8* nonnull inttoptr (i32 5 to i8*), i32 %stacksize, i8* undef, i8* null) #0
   ret void
 }
 
-declare void @main.regularFunction(i32, i8*)
+declare void @main.regularFunction(i32, i8*, i8*)
 
 ; Function Attrs: nounwind
 define linkonce_odr void @"main.regularFunction$gowrapper"(i8* %0) unnamed_addr #1 {
 entry:
   %unpack.int = ptrtoint i8* %0 to i32
-  call void @main.regularFunction(i32 %unpack.int, i8* undef) #0
+  call void @main.regularFunction(i32 %unpack.int, i8* undef, i8* undef) #0
   ret void
 }
 
-declare i32 @"internal/task.getGoroutineStackSize"(i32, i8*)
+declare i32 @"internal/task.getGoroutineStackSize"(i32, i8*, i8*)
 
-declare void @"internal/task.start"(i32, i8*, i32, i8*)
+declare void @"internal/task.start"(i32, i8*, i32, i8*, i8*)
 
 ; Function Attrs: nounwind
-define hidden void @main.inlineFunctionGoroutine(i8* %context) unnamed_addr #0 {
+define hidden void @main.inlineFunctionGoroutine(i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
-  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @"main.inlineFunctionGoroutine$1$gowrapper" to i32), i8* undef) #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) #0
+  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @"main.inlineFunctionGoroutine$1$gowrapper" to i32), i8* undef, i8* undef) #0
+  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"main.inlineFunctionGoroutine$1$gowrapper" to i32), i8* nonnull inttoptr (i32 5 to i8*), i32 %stacksize, i8* undef, i8* null) #0
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @"main.inlineFunctionGoroutine$1"(i32 %x, i8* %context) unnamed_addr #0 {
+define hidden void @"main.inlineFunctionGoroutine$1"(i32 %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   ret void
 }
@@ -60,31 +59,31 @@ entry:
 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)
+  call void @"main.inlineFunctionGoroutine$1"(i32 %unpack.int, i8* undef, i8* undef)
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.closureFunctionGoroutine(i8* %context) unnamed_addr #0 {
+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) #0
+  %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) #0
+  %1 = call i8* @runtime.alloc(i32 8, i8* null, i8* undef, i8* null) #0
   %2 = bitcast i8* %1 to i32*
   store i32 5, i32* %2, align 4
   %3 = getelementptr inbounds i8, i8* %1, i32 4
   %4 = bitcast i8* %3 to i8**
   store i8* %n, i8** %4, align 4
-  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @"main.closureFunctionGoroutine$1$gowrapper" to i32), 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) #0
+  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @"main.closureFunctionGoroutine$1$gowrapper" to i32), i8* undef, i8* undef) #0
+  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"main.closureFunctionGoroutine$1$gowrapper" to i32), i8* nonnull %1, i32 %stacksize, i8* undef, i8* null) #0
   %5 = load i32, i32* %0, align 4
-  call void @runtime.printint32(i32 %5, i8* undef) #0
+  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) unnamed_addr #0 {
+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
@@ -99,16 +98,16 @@ entry:
   %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)
+  call void @"main.closureFunctionGoroutine$1"(i32 %2, i8* %5, i8* undef)
   ret void
 }
 
-declare void @runtime.printint32(i32, i8*)
+declare void @runtime.printint32(i32, i8*, i8*)
 
 ; Function Attrs: nounwind
-define hidden void @main.funcGoroutine(i8* %fn.context, void ()* %fn.funcptr, i8* %context) unnamed_addr #0 {
+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) #0
+  %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
@@ -117,8 +116,8 @@ entry:
   %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) #0
-  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @main.funcGoroutine.gowrapper to i32), i8* nonnull %0, i32 %stacksize, i8* undef) #0
+  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @main.funcGoroutine.gowrapper to i32), i8* undef, i8* undef) #0
+  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @main.funcGoroutine.gowrapper to i32), i8* nonnull %0, i32 %stacksize, i8* undef, i8* null) #0
   ret void
 }
 
@@ -131,40 +130,40 @@ entry:
   %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*)**
-  %8 = load void (i32, i8*)*, void (i32, i8*)** %7, align 4
-  call void %8(i32 %2, i8* %5) #0
+  %7 = bitcast i8* %6 to void (i32, i8*, i8*)**
+  %8 = load void (i32, i8*, i8*)*, void (i32, i8*, i8*)** %7, align 4
+  call void %8(i32 %2, i8* %5, i8* undef) #0
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.recoverBuiltinGoroutine(i8* %context) unnamed_addr #0 {
+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) 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 #0 {
 entry:
-  %copy.n = call i32 @runtime.sliceCopy(i8* %dst.data, i8* %src.data, i32 %dst.len, i32 %src.len, i32 1, i8* undef) #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) #0
   ret void
 }
 
-declare i32 @runtime.sliceCopy(i8* nocapture writeonly, i8* nocapture readonly, i32, i32, i32, i8*)
+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) unnamed_addr #0 {
+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) #0
+  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*)
+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) unnamed_addr #0 {
+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) #0
+  %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
@@ -176,12 +175,12 @@ entry:
   %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) #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) #0
+  %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*) #5
+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 {
@@ -197,7 +196,7 @@ entry:
   %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) #0
+  call void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(i8* %2, i8* %5, i32 %8, i32 %11, i8* undef, i8* undef) #0
   ret void
 }
 

compiler/testdata/goroutine-wasm-asyncify.ll

@@ -1,59 +1,56 @@
 ; ModuleID = 'goroutine.go'
 source_filename = "goroutine.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128-ni:1:10:20"
+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.gcData", %"internal/task.state" }
-%"internal/task.gcData" = type { i8* }
+%"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*)
-
-declare void @runtime.trackPointer(i8* nocapture readonly, i8*)
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
 
 ; Function Attrs: nounwind
-define hidden void @main.init(i8* %context) unnamed_addr #0 {
+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) unnamed_addr #0 {
+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 16384, 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 8192, i8* undef, i8* null) #0
   ret void
 }
 
-declare void @main.regularFunction(i32, i8*)
+declare void @main.regularFunction(i32, i8*, i8*)
 
-declare void @runtime.deadlock(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) #0
-  call void @runtime.deadlock(i8* undef) #0
+  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*)
+declare void @"internal/task.start"(i32, i8*, i32, i8*, i8*)
 
 ; Function Attrs: nounwind
-define hidden void @main.inlineFunctionGoroutine(i8* %context) unnamed_addr #0 {
+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 16384, 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 8192, i8* undef, i8* null) #0
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @"main.inlineFunctionGoroutine$1"(i32 %x, i8* %context) unnamed_addr #0 {
+define hidden void @"main.inlineFunctionGoroutine$1"(i32 %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   ret void
 }
@@ -62,35 +59,31 @@ entry:
 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)
-  call void @runtime.deadlock(i8* undef) #0
+  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) unnamed_addr #0 {
+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) #0
+  %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*
-  call void @runtime.trackPointer(i8* nonnull %n, i8* undef) #0
   store i32 3, i32* %0, align 4
-  call void @runtime.trackPointer(i8* nonnull %n, i8* undef) #0
-  call void @runtime.trackPointer(i8* bitcast (void (i32, i8*)* @"main.closureFunctionGoroutine$1" to i8*), i8* undef) #0
-  %1 = call i8* @runtime.alloc(i32 8, i8* null, i8* undef) #0
-  call void @runtime.trackPointer(i8* nonnull %1, i8* undef) #0
+  %1 = call i8* @runtime.alloc(i32 8, i8* null, i8* undef, i8* null) #0
   %2 = bitcast i8* %1 to i32*
   store i32 5, i32* %2, align 4
   %3 = getelementptr inbounds i8, i8* %1, i32 4
   %4 = bitcast i8* %3 to i8**
   store i8* %n, i8** %4, align 4
-  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"main.closureFunctionGoroutine$1$gowrapper" to i32), i8* nonnull %1, i32 16384, i8* undef) #0
+  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) #0
+  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) unnamed_addr #0 {
+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
@@ -105,18 +98,17 @@ entry:
   %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)
-  call void @runtime.deadlock(i8* undef) #0
+  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*)
+declare void @runtime.printint32(i32, i8*, i8*)
 
 ; Function Attrs: nounwind
-define hidden void @main.funcGoroutine(i8* %fn.context, void ()* %fn.funcptr, i8* %context) unnamed_addr #0 {
+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) #0
-  call void @runtime.trackPointer(i8* nonnull %0, i8* undef) #0
+  %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
@@ -125,7 +117,7 @@ entry:
   %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 16384, i8* undef) #0
+  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
 }
 
@@ -138,42 +130,41 @@ entry:
   %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*)**
-  %8 = load void (i32, i8*)*, void (i32, i8*)** %7, align 4
-  call void %8(i32 %2, i8* %5) #0
-  call void @runtime.deadlock(i8* undef) #0
+  %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) unnamed_addr #0 {
+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) 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 #0 {
 entry:
-  %copy.n = call i32 @runtime.sliceCopy(i8* %dst.data, i8* %src.data, i32 %dst.len, i32 %src.len, i32 1, i8* undef) #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) #0
   ret void
 }
 
-declare i32 @runtime.sliceCopy(i8* nocapture writeonly, i8* nocapture readonly, i32, i32, i32, i8*)
+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) unnamed_addr #0 {
+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) #0
+  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*)
+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) unnamed_addr #0 {
+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) #0
-  call void @runtime.trackPointer(i8* nonnull %0, i8* undef) #0
+  %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
@@ -185,11 +176,11 @@ entry:
   %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 16384, 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 8192, i8* undef, i8* null) #0
   ret void
 }
 
-declare void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(i8*, i8*, i32, i32, i8*) #5
+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 {
@@ -205,8 +196,8 @@ entry:
   %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) #0
-  call void @runtime.deadlock(i8* undef) #0
+  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
 }
 

compiler/testdata/goroutine-wasm-coroutines.ll

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

compiler/testdata/interface.ll

@@ -1,6 +1,6 @@
 ; ModuleID = 'interface.go'
 source_filename = "interface.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128-ni:1:10:20"
+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 }
@@ -22,52 +22,46 @@ target triple = "wasm32-unknown-wasi"
 @"reflect/types.interface:interface{String() string}$interface" = linkonce_odr constant [1 x i8*] [i8* @"reflect/methods.String() string"]
 @"reflect/types.typeid:basic:int" = external constant i8
 
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
-
-declare void @runtime.trackPointer(i8* nocapture readonly, i8*)
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
 
 ; Function Attrs: nounwind
-define hidden void @main.init(i8* %context) unnamed_addr #0 {
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden %runtime._interface @main.simpleType(i8* %context) unnamed_addr #0 {
+define hidden %runtime._interface @main.simpleType(i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
-  call void @runtime.trackPointer(i8* null, i8* undef) #0
   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) unnamed_addr #0 {
+define hidden %runtime._interface @main.pointerType(i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
-  call void @runtime.trackPointer(i8* null, i8* undef) #0
   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) unnamed_addr #0 {
+define hidden %runtime._interface @main.interfaceType(i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
-  call void @runtime.trackPointer(i8* null, i8* undef) #0
   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) unnamed_addr #0 {
+define hidden %runtime._interface @main.anonymousInterfaceType(i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
-  call void @runtime.trackPointer(i8* null, i8* undef) #0
   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) unnamed_addr #0 {
+define hidden i1 @main.isInt(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
-  %typecode = call i1 @runtime.typeAssert(i32 %itf.typecode, i8* nonnull @"reflect/types.typeid:basic:int", i8* undef) #0
+  %typecode = call i1 @runtime.typeAssert(i32 %itf.typecode, i8* nonnull @"reflect/types.typeid:basic:int", i8* undef, i8* null) #0
   br i1 %typecode, label %typeassert.ok, label %typeassert.next
 
 typeassert.ok:                                    ; preds = %entry
@@ -77,10 +71,10 @@ typeassert.next:                                  ; preds = %typeassert.ok, %ent
   ret i1 %typecode
 }
 
-declare i1 @runtime.typeAssert(i32, i8* dereferenceable_or_null(1), i8*)
+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) unnamed_addr #0 {
+define hidden i1 @main.isError(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   %0 = call i1 @"interface:{Error:func:{}{basic:string}}.$typeassert"(i32 %itf.typecode) #0
   br i1 %0, label %typeassert.ok, label %typeassert.next
@@ -93,7 +87,7 @@ typeassert.next:                                  ; preds = %typeassert.ok, %ent
 }
 
 ; Function Attrs: nounwind
-define hidden i1 @main.isStringer(i32 %itf.typecode, i8* %itf.value, i8* %context) unnamed_addr #0 {
+define hidden i1 @main.isStringer(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   %0 = call i1 @"interface:{String:func:{}{basic:string}}.$typeassert"(i32 %itf.typecode) #0
   br i1 %0, label %typeassert.ok, label %typeassert.next
@@ -106,24 +100,22 @@ typeassert.next:                                  ; preds = %typeassert.ok, %ent
 }
 
 ; Function Attrs: nounwind
-define hidden i8 @main.callFooMethod(i32 %itf.typecode, i8* %itf.value, i8* %context) unnamed_addr #0 {
+define hidden i8 @main.callFooMethod(i32 %itf.typecode, i8* %itf.value, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
-  %0 = call i8 @"interface:{String:func:{}{basic:string},main.foo:func:{basic:int}{basic:uint8}}.foo$invoke"(i8* %itf.value, i32 3, i32 %itf.typecode, i8* undef) #0
+  %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*) #3
+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) unnamed_addr #0 {
+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) #0
-  %1 = extractvalue %runtime._string %0, 0
-  call void @runtime.trackPointer(i8* %1, i8* undef) #0
+  %0 = call %runtime._string @"interface:{Error:func:{}{basic:string}}.Error$invoke"(i8* %itf.value, i32 %itf.typecode, i8* undef, i8* undef) #0
   ret %runtime._string %0
 }
 
-declare %runtime._string @"interface:{Error:func:{}{basic:string}}.Error$invoke"(i8*, i32, i8*) #4
+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" }

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

@@ -3,30 +3,30 @@ 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*)
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
 
 ; Function Attrs: nounwind
-define hidden void @main.init(i8* %context) unnamed_addr #0 {
+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) unnamed_addr #0 {
+define hidden double @main.mySqrt(double %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
-  %0 = call double @math.Sqrt(double %x, i8* undef) #0
+  %0 = call double @math.Sqrt(double %x, i8* undef, i8* undef) #0
   ret double %0
 }
 
-declare double @math.Sqrt(double, i8*)
+declare double @math.Sqrt(double, i8*, i8*)
 
 ; Function Attrs: nounwind
-define hidden double @main.myTrunc(double %x, i8* %context) unnamed_addr #0 {
+define hidden double @main.myTrunc(double %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
-  %0 = call double @math.Trunc(double %x, i8* undef) #0
+  %0 = call double @math.Trunc(double %x, i8* undef, i8* undef) #0
   ret double %0
 }
 
-declare double @math.Trunc(double, i8*)
+declare double @math.Trunc(double, i8*, i8*)
 
 attributes #0 = { nounwind }

compiler/testdata/intrinsics-wasm.ll

@@ -1,37 +1,35 @@
 ; ModuleID = 'intrinsics.go'
 source_filename = "intrinsics.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128-ni:1:10:20"
+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*)
-
-declare void @runtime.trackPointer(i8* nocapture readonly, i8*)
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
 
 ; Function Attrs: nounwind
-define hidden void @main.init(i8* %context) unnamed_addr #0 {
+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) unnamed_addr #0 {
+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
+; Function Attrs: nounwind readnone speculatable willreturn
 declare double @llvm.sqrt.f64(double) #1
 
 ; Function Attrs: nounwind
-define hidden double @main.myTrunc(double %x, i8* %context) unnamed_addr #0 {
+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
+; Function Attrs: nounwind readnone speculatable willreturn
 declare double @llvm.trunc.f64(double) #1
 
 attributes #0 = { nounwind }
-attributes #1 = { nofree nosync nounwind readnone speculatable willreturn }
+attributes #1 = { nounwind readnone speculatable willreturn }

compiler/testdata/pointer.ll

@@ -1,78 +1,61 @@
 ; ModuleID = 'pointer.go'
 source_filename = "pointer.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128-ni:1:10:20"
+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*)
-
-declare void @runtime.trackPointer(i8* nocapture readonly, i8*)
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
 
 ; Function Attrs: nounwind
-define hidden void @main.init(i8* %context) unnamed_addr #0 {
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden [0 x i32] @main.pointerDerefZero([0 x i32]* %x, i8* %context) unnamed_addr #0 {
+define hidden [0 x i32] @main.pointerDerefZero([0 x i32]* %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   ret [0 x i32] zeroinitializer
 }
 
 ; Function Attrs: nounwind
-define hidden i32* @main.pointerCastFromUnsafe(i8* %x, i8* %context) unnamed_addr #0 {
+define hidden i32* @main.pointerCastFromUnsafe(i8* %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   %0 = bitcast i8* %x to i32*
-  call void @runtime.trackPointer(i8* %x, i8* undef) #0
   ret i32* %0
 }
 
 ; Function Attrs: nounwind
-define hidden i8* @main.pointerCastToUnsafe(i32* dereferenceable_or_null(4) %x, i8* %context) unnamed_addr #0 {
+define hidden i8* @main.pointerCastToUnsafe(i32* dereferenceable_or_null(4) %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   %0 = bitcast i32* %x to i8*
-  call void @runtime.trackPointer(i8* %0, i8* undef) #0
   ret i8* %0
 }
 
 ; Function Attrs: nounwind
-define hidden i8* @main.pointerCastToUnsafeNoop(i8* dereferenceable_or_null(1) %x, i8* %context) unnamed_addr #0 {
+define hidden i8* @main.pointerCastToUnsafeNoop(i8* dereferenceable_or_null(1) %x, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
-  call void @runtime.trackPointer(i8* %x, i8* undef) #0
   ret i8* %x
 }
 
 ; Function Attrs: nounwind
-define hidden i8* @main.pointerUnsafeGEPFixedOffset(i8* dereferenceable_or_null(1) %ptr, i8* %context) unnamed_addr #0 {
+define hidden i8* @main.pointerUnsafeGEPFixedOffset(i8* dereferenceable_or_null(1) %ptr, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
-  call void @runtime.trackPointer(i8* %ptr, i8* undef) #0
   %0 = getelementptr inbounds i8, i8* %ptr, i32 10
-  call void @runtime.trackPointer(i8* nonnull %0, i8* undef) #0
-  call void @runtime.trackPointer(i8* nonnull %0, i8* undef) #0
   ret i8* %0
 }
 
 ; Function Attrs: nounwind
-define hidden i8* @main.pointerUnsafeGEPByteOffset(i8* dereferenceable_or_null(1) %ptr, i32 %offset, i8* %context) unnamed_addr #0 {
+define hidden i8* @main.pointerUnsafeGEPByteOffset(i8* dereferenceable_or_null(1) %ptr, i32 %offset, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
-  call void @runtime.trackPointer(i8* %ptr, i8* undef) #0
   %0 = getelementptr inbounds i8, i8* %ptr, i32 %offset
-  call void @runtime.trackPointer(i8* %0, i8* undef) #0
-  call void @runtime.trackPointer(i8* %0, i8* undef) #0
   ret i8* %0
 }
 
 ; Function Attrs: nounwind
-define hidden i32* @main.pointerUnsafeGEPIntOffset(i32* dereferenceable_or_null(4) %ptr, i32 %offset, i8* %context) unnamed_addr #0 {
+define hidden i32* @main.pointerUnsafeGEPIntOffset(i32* dereferenceable_or_null(4) %ptr, i32 %offset, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
-  %0 = bitcast i32* %ptr to i8*
-  call void @runtime.trackPointer(i8* %0, i8* undef) #0
-  %1 = getelementptr i32, i32* %ptr, i32 %offset
-  %2 = bitcast i32* %1 to i8*
-  call void @runtime.trackPointer(i8* %2, i8* undef) #0
-  %3 = bitcast i32* %1 to i8*
-  call void @runtime.trackPointer(i8* %3, i8* undef) #0
-  ret i32* %1
+  %0 = getelementptr i32, i32* %ptr, i32 %offset
+  ret i32* %0
 }
 
 attributes #0 = { nounwind }

compiler/testdata/pragma.ll

@@ -1,6 +1,6 @@
 ; ModuleID = 'pragma.go'
 source_filename = "pragma.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128-ni:1:10:20"
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-wasi"
 
 @extern_global = external global [0 x i8], align 1
@@ -10,12 +10,10 @@ 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*)
-
-declare void @runtime.trackPointer(i8* nocapture readonly, i8*)
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
 
 ; Function Attrs: nounwind
-define hidden void @main.init(i8* %context) unnamed_addr #0 {
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   ret void
 }
@@ -27,27 +25,27 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden void @somepkg.someFunction1(i8* %context) unnamed_addr #0 {
+define hidden void @somepkg.someFunction1(i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   ret void
 }
 
-declare void @somepkg.someFunction2(i8*)
+declare void @somepkg.someFunction2(i8*, i8*)
 
 ; Function Attrs: inlinehint nounwind
-define hidden void @main.inlineFunc(i8* %context) unnamed_addr #2 {
+define hidden void @main.inlineFunc(i8* %context, i8* %parentHandle) unnamed_addr #2 {
 entry:
   ret void
 }
 
 ; Function Attrs: noinline nounwind
-define hidden void @main.noinlineFunc(i8* %context) unnamed_addr #3 {
+define hidden void @main.noinlineFunc(i8* %context, i8* %parentHandle) unnamed_addr #3 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.functionInSection(i8* %context) unnamed_addr #0 section ".special_function_section" {
+define hidden void @main.functionInSection(i8* %context, i8* %parentHandle) unnamed_addr #0 section ".special_function_section" {
 entry:
   ret void
 }
@@ -58,7 +56,7 @@ entry:
   ret void
 }
 
-declare void @main.undefinedFunctionNotInSection(i8*)
+declare void @main.undefinedFunctionNotInSection(i8*, i8*)
 
 attributes #0 = { nounwind }
 attributes #1 = { nounwind "wasm-export-name"="extern_func" }

compiler/testdata/slice.ll

@@ -1,38 +1,36 @@
 ; ModuleID = 'slice.go'
 source_filename = "slice.go"
-target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128-ni:1:10:20"
+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*)
-
-declare void @runtime.trackPointer(i8* nocapture readonly, i8*)
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*, i8*)
 
 ; Function Attrs: nounwind
-define hidden void @main.init(i8* %context) unnamed_addr #0 {
+define hidden void @main.init(i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.sliceLen(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i8* %context) unnamed_addr #0 {
+define hidden i32 @main.sliceLen(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   ret i32 %ints.len
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.sliceCap(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i8* %context) unnamed_addr #0 {
+define hidden i32 @main.sliceCap(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i8* %context, i8* %parentHandle) unnamed_addr #0 {
 entry:
   ret i32 %ints.cap
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.sliceElement(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i32 %index, i8* %context) 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 #0 {
 entry:
   %.not = icmp ult i32 %index, %ints.len
   br i1 %.not, label %lookup.next, label %lookup.throw
 
 lookup.throw:                                     ; preds = %entry
-  call void @runtime.lookupPanic(i8* undef) #0
+  call void @runtime.lookupPanic(i8* undef, i8* null) #0
   unreachable
 
 lookup.next:                                      ; preds = %entry
@@ -41,13 +39,12 @@ lookup.next:                                      ; preds = %entry
   ret i32 %1
 }
 
-declare void @runtime.lookupPanic(i8*)
+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) 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 #0 {
 entry:
-  %varargs = call i8* @runtime.alloc(i32 12, i8* nonnull inttoptr (i32 3 to i8*), i8* undef) #0
-  call void @runtime.trackPointer(i8* nonnull %varargs, i8* undef) #0
+  %varargs = call i8* @runtime.alloc(i32 12, i8* nonnull inttoptr (i32 3 to i8*), i8* undef, i8* null) #0
   %0 = bitcast i8* %varargs to i32*
   store i32 1, i32* %0, align 4
   %1 = getelementptr inbounds i8, i8* %varargs, i32 4
@@ -57,7 +54,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) #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) #0
   %append.newPtr = extractvalue { i8*, i32, i32 } %append.new, 0
   %append.newBuf = bitcast i8* %append.newPtr to i32*
   %append.newLen = extractvalue { i8*, i32, i32 } %append.new, 1
@@ -65,18 +62,17 @@ entry:
   %5 = insertvalue { i32*, i32, i32 } undef, i32* %append.newBuf, 0
   %6 = insertvalue { i32*, i32, i32 } %5, i32 %append.newLen, 1
   %7 = insertvalue { i32*, i32, i32 } %6, i32 %append.newCap, 2
-  call void @runtime.trackPointer(i8* %append.newPtr, i8* undef) #0
   ret { i32*, i32, i32 } %7
 }
 
-declare { i8*, i32, i32 } @runtime.sliceAppend(i8*, i8* nocapture readonly, i32, i32, i32, i32, i8*)
+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) 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 #0 {
 entry:
   %append.srcPtr = bitcast i32* %ints.data to i8*
   %append.srcPtr1 = bitcast i32* %added.data to i8*
-  %append.new = call { i8*, i32, i32 } @runtime.sliceAppend(i8* %append.srcPtr, i8* %append.srcPtr1, i32 %ints.len, i32 %ints.cap, i32 %added.len, i32 4, i8* undef) #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) #0
   %append.newPtr = extractvalue { i8*, i32, i32 } %append.new, 0
   %append.newBuf = bitcast i8* %append.newPtr to i32*
   %append.newLen = extractvalue { i8*, i32, i32 } %append.new, 1
@@ -84,102 +80,97 @@ entry:
   %0 = insertvalue { i32*, i32, i32 } undef, i32* %append.newBuf, 0
   %1 = insertvalue { i32*, i32, i32 } %0, i32 %append.newLen, 1
   %2 = insertvalue { i32*, i32, i32 } %1, i32 %append.newCap, 2
-  call void @runtime.trackPointer(i8* %append.newPtr, i8* undef) #0
   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) 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 #0 {
 entry:
   %copy.dstPtr = bitcast i32* %dst.data to i8*
   %copy.srcPtr = bitcast i32* %src.data to i8*
-  %copy.n = call i32 @runtime.sliceCopy(i8* %copy.dstPtr, i8* %copy.srcPtr, i32 %dst.len, i32 %src.len, i32 4, i8* undef) #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) #0
   ret i32 %copy.n
 }
 
-declare i32 @runtime.sliceCopy(i8* nocapture writeonly, i8* nocapture readonly, i32, i32, i32, i8*)
+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) unnamed_addr #0 {
+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) #0
+  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) #0
+  %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
-  call void @runtime.trackPointer(i8* nonnull %makeslice.buf, i8* undef) #0
   ret { i8*, i32, i32 } %2
 }
 
-declare void @runtime.slicePanic(i8*)
+declare void @runtime.slicePanic(i8*, i8*)
 
 ; Function Attrs: nounwind
-define hidden { i16*, i32, i32 } @main.makeInt16Slice(i32 %len, i8* %context) unnamed_addr #0 {
+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) #0
+  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) #0
+  %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
-  call void @runtime.trackPointer(i8* nonnull %makeslice.buf, i8* undef) #0
   ret { i16*, i32, i32 } %2
 }
 
 ; Function Attrs: nounwind
-define hidden { [3 x i8]*, i32, i32 } @main.makeArraySlice(i32 %len, i8* %context) unnamed_addr #0 {
+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) #0
+  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) #0
+  %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
-  call void @runtime.trackPointer(i8* nonnull %makeslice.buf, i8* undef) #0
   ret { [3 x i8]*, i32, i32 } %2
 }
 
 ; Function Attrs: nounwind
-define hidden { i32*, i32, i32 } @main.makeInt32Slice(i32 %len, i8* %context) unnamed_addr #0 {
+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) #0
+  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) #0
+  %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
-  call void @runtime.trackPointer(i8* nonnull %makeslice.buf, i8* undef) #0
   ret { i32*, i32, i32 } %2
 }
 

compiler/testdata/string.ll

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

corpus_test.go

@@ -1,177 +0,0 @@
-package main
-
-import (
-	"flag"
-	"os"
-	"os/exec"
-	"strings"
-	"sync"
-	"testing"
-
-	yaml "gopkg.in/yaml.v2"
-)
-
-/*
-This contains code from https://github.com/dgryski/tinygo-test-corpus
-
-The MIT License (MIT)
-
-Copyright (c) 2020 Damian Gryski <damian@gryski.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
-*/
-
-var corpus = flag.String("corpus", "", "path to test corpus")
-
-func TestCorpus(t *testing.T) {
-	t.Parallel()
-	if *corpus == "" {
-		t.Skip()
-	}
-
-	var target string
-	if *testTarget != "" {
-		target = *testTarget
-	}
-
-	repos, err := loadRepos(*corpus)
-	if err != nil {
-		t.Fatalf("loading corpus: %v", err)
-	}
-
-	for _, repo := range repos {
-		repo := repo
-		name := repo.Repo
-		if repo.Tags != "" {
-			name += "(" + strings.ReplaceAll(repo.Tags, " ", "-") + ")"
-		}
-		if repo.Version != "" {
-			name += "@" + repo.Version
-		}
-		t.Run(name, func(t *testing.T) {
-			t.Parallel()
-
-			if target == "wasi" && repo.SkipWASI {
-				t.Skip("skip wasi")
-			}
-			if repo.Slow && testing.Short() {
-				t.Skip("slow test")
-			}
-
-			var wg sync.WaitGroup
-			defer wg.Wait()
-			out := ioLogger(t, &wg)
-			defer out.Close()
-
-			dir := t.TempDir()
-			cmd := exec.Command("go", "mod", "init", "github.com/tinygo/tinygo-corpus-test")
-			cmd.Dir = dir
-			cmd.Stdout, cmd.Stderr = out, out
-			err := cmd.Run()
-			if err != nil {
-				t.Errorf("failed to init: %s", err.Error())
-				return
-			}
-
-			var ver string
-			if repo.Version != "" {
-				ver = "@" + repo.Version
-			}
-			cmd = exec.Command("go", "get", "-t", "-d", repo.Repo+"/..."+ver)
-			cmd.Dir = dir
-			cmd.Stdout, cmd.Stderr = out, out
-			err = cmd.Run()
-			if err != nil {
-				t.Errorf("failed to get: %s", err.Error())
-				return
-			}
-
-			doTest := func(t *testing.T, path string) {
-				var wg sync.WaitGroup
-				defer wg.Wait()
-				out := ioLogger(t, &wg)
-				defer out.Close()
-
-				opts := optionsFromTarget(target, sema)
-				opts.Directory = dir
-				opts.Tags = repo.Tags
-
-				passed, err := Test(path, out, out, &opts, false, testing.Verbose(), false, "", "", "", "")
-				if err != nil {
-					t.Errorf("test error: %v", err)
-				}
-				if !passed {
-					t.Error("test failed")
-				}
-			}
-			if len(repo.Subdirs) == 0 {
-				doTest(t, repo.Repo)
-				return
-			}
-
-			for _, dir := range repo.Subdirs {
-				dir := dir
-				t.Run(dir.Pkg, func(t *testing.T) {
-					t.Parallel()
-
-					if target == "wasi" && dir.SkipWASI {
-						t.Skip("skip wasi")
-					}
-					if dir.Slow && testing.Short() {
-						t.Skip("slow test")
-					}
-
-					doTest(t, repo.Repo+"/"+dir.Pkg)
-				})
-			}
-		})
-	}
-}
-
-type T struct {
-	Repo     string
-	Tags     string
-	Subdirs  []Subdir
-	SkipWASI bool
-	Slow     bool
-	Version  string
-}
-
-type Subdir struct {
-	Pkg      string
-	SkipWASI bool
-	Slow     bool
-}
-
-func loadRepos(f string) ([]T, error) {
-
-	yf, err := os.ReadFile(f)
-	if err != nil {
-		return nil, err
-	}
-
-	var repos []T
-	err = yaml.Unmarshal(yf, &repos)
-	if err != nil {
-		return nil, err
-	}
-
-	return repos, nil
-}

go.mod

@@ -3,17 +3,15 @@ module github.com/tinygo-org/tinygo
 go 1.15
 
 require (
-	github.com/aykevl/go-wasm v0.0.2-0.20211119014117-0761b1ddcd1a
+	github.com/aykevl/go-wasm v0.0.2-0.20211030161413-11881cb9032d // indirect
 	github.com/blakesmith/ar v0.0.0-20150311145944-8bd4349a67f2
-	github.com/chromedp/cdproto v0.0.0-20220113222801-0725d94bb6ee
-	github.com/chromedp/chromedp v0.7.6
-	github.com/gofrs/flock v0.8.1
+	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/sys v0.0.0-20220114195835-da31bd327af9
+	golang.org/x/sys v0.0.0-20210510120138-977fb7262007
 	golang.org/x/tools v0.1.6-0.20210813165731-45389f592fe9
-	gopkg.in/yaml.v2 v2.4.0
-	tinygo.org/x/go-llvm v0.0.0-20220121152956-4fa2ab2718f3
+	tinygo.org/x/go-llvm v0.0.0-20210325115028-e7b85195e81c
 )

go.sum

@@ -1,51 +1,45 @@
-github.com/aykevl/go-wasm v0.0.2-0.20211119014117-0761b1ddcd1a h1:QPU7APo6y/6VkCDq6HU3WWIUzER8iywSac23+1UQv60=
-github.com/aykevl/go-wasm v0.0.2-0.20211119014117-0761b1ddcd1a/go.mod h1:7sXyiaA0WtSogCu67R2252fQpVmJMh9JWJ9ddtGkpWw=
+github.com/aykevl/go-wasm v0.0.2-0.20211030161413-11881cb9032d h1:JeuI5/546naK5hpOIX+Lq5xE8rvt7uwiTp6iL+pLQgk=
+github.com/aykevl/go-wasm v0.0.2-0.20211030161413-11881cb9032d/go.mod h1:7sXyiaA0WtSogCu67R2252fQpVmJMh9JWJ9ddtGkpWw=
 github.com/blakesmith/ar v0.0.0-20150311145944-8bd4349a67f2 h1:oMCHnXa6CCCafdPDbMh/lWRhRByN0VFLvv+g+ayx1SI=
 github.com/blakesmith/ar v0.0.0-20150311145944-8bd4349a67f2/go.mod h1:PkYb9DJNAwrSvRx5DYA+gUcOIgTGVMNkfSCbZM8cWpI=
-github.com/chromedp/cdproto v0.0.0-20211126220118-81fa0469ad77/go.mod h1:At5TxYYdxkbQL0TSefRjhLE3Q0lgvqKKMSFUglJ7i1U=
-github.com/chromedp/cdproto v0.0.0-20220113222801-0725d94bb6ee h1:+SFdIVfQpG0s0DHYzou0kgfE0n0ZjKPwbiRJsXrZegU=
-github.com/chromedp/cdproto v0.0.0-20220113222801-0725d94bb6ee/go.mod h1:At5TxYYdxkbQL0TSefRjhLE3Q0lgvqKKMSFUglJ7i1U=
-github.com/chromedp/chromedp v0.7.6 h1:2juGaktzjwULlsn+DnvIZXFUckEp5xs+GOBroaea+jA=
-github.com/chromedp/chromedp v0.7.6/go.mod h1:ayT4YU/MGAALNfOg9gNrpGSAdnU51PMx+FCeuT1iXzo=
+github.com/chromedp/cdproto v0.0.0-20210113043257-dabd2f2e7693 h1:11eq/RkpaotwdF6b1TRMcdgQUPNmyFEJOB7zLvh0O/Y=
+github.com/chromedp/cdproto v0.0.0-20210113043257-dabd2f2e7693/go.mod h1:55pim6Ht4LJKdVLlyFJV/g++HsEA1hQxPbB5JyNdZC0=
+github.com/chromedp/chromedp v0.6.4 h1:Gx7ZkRyrSVmbbDDja/ieNgNGJIvElroPOyeqYQGVDSY=
+github.com/chromedp/chromedp v0.6.4/go.mod h1:vodUdJf5dF/b8n0UBJv6NeM/QK28RjP3j+eM7fq4+84=
 github.com/chromedp/sysutil v1.0.0 h1:+ZxhTpfpZlmchB58ih/LBHX52ky7w2VhQVKQMucy3Ic=
 github.com/chromedp/sysutil v1.0.0/go.mod h1:kgWmDdq8fTzXYcKIBqIYvRRTnYb9aNS9moAV0xufSww=
 github.com/creack/goselect v0.1.2 h1:2DNy14+JPjRBgPzAd1thbQp4BSIihxcBf0IXhQXDRa0=
 github.com/creack/goselect v0.1.2/go.mod h1:a/NhLweNvqIYMuxcMOuWY516Cimucms3DglDzQP3hKY=
-github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/gobwas/httphead v0.1.0 h1:exrUm0f4YX0L7EBwZHuCF4GDp8aJfVeBrlLQrs6NqWU=
 github.com/gobwas/httphead v0.1.0/go.mod h1:O/RXo79gxV8G+RqlR/otEwx4Q36zl9rqC5u12GKvMCM=
 github.com/gobwas/pool v0.2.1 h1:xfeeEhW7pwmX8nuLVlqbzVc7udMDrwetjEv+TZIz1og=
 github.com/gobwas/pool v0.2.1/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
-github.com/gobwas/ws v1.1.0 h1:7RFti/xnNkMJnrK7D1yQ/iCIB5OrrY/54/H930kIbHA=
-github.com/gobwas/ws v1.1.0/go.mod h1:nzvNcVha5eUziGrbxFCo6qFIojQHjJV5cLYIbezhfL0=
-github.com/gofrs/flock v0.8.1 h1:+gYjHKf32LDeiEEFhQaotPbLuUXjY5ZqxKgXy7n59aw=
-github.com/gofrs/flock v0.8.1/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU=
+github.com/gobwas/ws v1.0.4 h1:5eXU1CZhpQdq5kXbKb+sECH5Ia5KiO6CYzIzdlVx6Bs=
+github.com/gobwas/ws v1.0.4/go.mod h1:szmBTxLgaFppYjEmNtny/v3w89xOydFnnZMcgRRu/EM=
 github.com/google/shlex v0.0.0-20181106134648-c34317bd91bf h1:7+FW5aGwISbqUtkfmIpZJGRgNFg2ioYPvFaUxdqpDsg=
 github.com/google/shlex v0.0.0-20181106134648-c34317bd91bf/go.mod h1:RpwtwJQFrIEPstU94h88MWPXP2ektJZ8cZ0YntAmXiE=
 github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY=
 github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
-github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0=
-github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
+github.com/mailru/easyjson v0.7.6 h1:8yTIVnZgCoiM1TgqoeTl+LfU5Jg6/xL3QhGQnimLYnA=
+github.com/mailru/easyjson v0.7.6/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
 github.com/marcinbor85/gohex v0.0.0-20200531091804-343a4b548892 h1:6J+qramlHVLmiBOgRiBOnQkno8uprqG6YFFQTt6uYIw=
 github.com/marcinbor85/gohex v0.0.0-20200531091804-343a4b548892/go.mod h1:Pb6XcsXyropB9LNHhnqaknG/vEwYztLkQzVCHv8sQ3M=
 github.com/mattn/go-colorable v0.1.8 h1:c1ghPdyEDarC70ftn0y+A/Ee++9zz8ljHG1b13eJ0s8=
 github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
 github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
 github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
-github.com/orisano/pixelmatch v0.0.0-20210112091706-4fa4c7ba91d5 h1:1SoBaSPudixRecmlHXb/GxmaD3fLMtHIDN13QujwQuc=
-github.com/orisano/pixelmatch v0.0.0-20210112091706-4fa4c7ba91d5/go.mod h1:nZgzbfBr3hhjoZnS66nKrHmduYNpc34ny7RK4z5/HM0=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/yuin/goldmark v1.3.5 h1:dPmz1Snjq0kmkz159iL7S6WzdahUTHnHB5M56WFVifs=
 github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
 go.bug.st/serial v1.1.3 h1:YEBxJa9pKS9Wdg46B/jiaKbvvbUrjhZZZITfJHEJhaE=
 go.bug.st/serial v1.1.3/go.mod h1:8TT7u/SwwNIpJ8QaG4s+HTjFt9ReXs2cdOU7ZEk50Dk=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/mod v0.4.2 h1:Gz96sIWK3OalVv/I/qNygP42zyoKp3xptRVCWRFEBvo=
+golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee h1:WG0RUwxtNT4qqaXX3DPA8zHFNm/D9xaBpxzHt1WcA/E=
+golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
 golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
@@ -58,12 +52,10 @@ golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200909081042-eff7692f9009/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201207223542-d4d67f95c62d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210113181707-4bcb84eeeb78/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210510120138-977fb7262007 h1:gG67DSER+11cZvqIMb8S8bt0vZtiN6xWYARwirrOSfE=
 golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20211124211545-fe61309f8881/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220114195835-da31bd327af9 h1:XfKQ4OlFl8okEOr5UvAqFRVj8pY/4yfcXrddB8qAbU0=
-golang.org/x/sys v0.0.0-20220114195835-da31bd327af9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
@@ -73,12 +65,10 @@ golang.org/x/tools v0.1.6-0.20210813165731-45389f592fe9 h1:nvvuMxmx1q0gfRki3T0hj
 golang.org/x/tools v0.1.6-0.20210813165731-45389f592fe9/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
-gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
-tinygo.org/x/go-llvm v0.0.0-20220121152956-4fa2ab2718f3 h1:vQSFy0kNQegAfL/F6iyWQa4bF941Xc1gyJUkGy2m448=
-tinygo.org/x/go-llvm v0.0.0-20220121152956-4fa2ab2718f3/go.mod h1:GFbusT2VTA4I+l4j80b17KFK+6whv69Wtny5U+T8RR0=
+tinygo.org/x/go-llvm v0.0.0-20210308112806-9ef958b6bed4 h1:CMUHxVTb+UuUePuMf8vkWjZ3gTp9BBK91KrgOCwoNHs=
+tinygo.org/x/go-llvm v0.0.0-20210308112806-9ef958b6bed4/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=
+tinygo.org/x/go-llvm v0.0.0-20210325115028-e7b85195e81c h1:vn9IPshzYmzZis10UEVrsIBRv9FpykADw6M3/tHHROg=
+tinygo.org/x/go-llvm v0.0.0-20210325115028-e7b85195e81c/go.mod h1:fv1F0BSNpxMfCL0zF3M4OPFbgYHnhtB6ST0HvUtu/LE=

goenv/version.go

@@ -12,7 +12,7 @@ import (
 
 // Version of TinyGo.
 // Update this value before release of new version of software.
-const Version = "0.22.0"
+const Version = "0.21.0-dev"
 
 // GetGorootVersion returns the major and minor version for a given GOROOT path.
 // If the goroot cannot be determined, (0, 0) is returned.

interp/interp.go

@@ -11,6 +11,12 @@ import (
 	"tinygo.org/x/go-llvm"
 )
 
+// Version of the interp package. It must be incremented whenever the interp
+// 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 = 2 // last change: fix GEP on untyped pointers
+
 // Enable extra checks, which should be disabled by default.
 // This may help track down bugs by adding a few more sanity checks.
 const checks = true
@@ -22,7 +28,6 @@ type runner struct {
 	builder       llvm.Builder
 	pointerSize   uint32                   // cached pointer size from the TargetData
 	i8ptrType     llvm.Type                // often used type so created in advance
-	uintptrType   llvm.Type                // equivalent to uintptr in Go
 	maxAlign      int                      // maximum alignment of an object, alignment of runtime.alloc() result
 	debug         bool                     // log debug messages
 	pkgName       string                   // package name of the currently executing package
@@ -45,7 +50,6 @@ func newRunner(mod llvm.Module, debug bool) *runner {
 	}
 	r.pointerSize = uint32(r.targetData.PointerSize())
 	r.i8ptrType = llvm.PointerType(mod.Context().Int8Type(), 0)
-	r.uintptrType = mod.Context().IntType(r.targetData.PointerSize() * 8)
 	r.maxAlign = r.targetData.PrefTypeAlignment(r.i8ptrType) // assume pointers are maximally aligned (this is not always the case)
 	return &r
 }
@@ -118,7 +122,7 @@ func Run(mod llvm.Module, debug bool) error {
 				// Create a call to the package initializer (which was
 				// previously deleted).
 				i8undef := llvm.Undef(r.i8ptrType)
-				r.builder.CreateCall(fn, []llvm.Value{i8undef}, "")
+				r.builder.CreateCall(fn, []llvm.Value{i8undef, i8undef}, "")
 				// Make sure that any globals touched by the package
 				// initializer, won't be accessed by later package initializers.
 				r.markExternalLoad(fn)

interp/interp_test.go

@@ -71,7 +71,6 @@ func runTest(t *testing.T, pathPrefix string) {
 	defer pm.Dispose()
 	pm.AddGlobalOptimizerPass()
 	pm.AddDeadStoreEliminationPass()
-	pm.AddAggressiveDCEPass()
 	pm.Run(mod)
 
 	// Read the expected output IR.

interp/interpreter.go

@@ -17,7 +17,10 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 	locals := make([]value, len(fn.locals))
 	r.callsExecuted++
 
-	t0 := time.Since(r.start)
+	if time.Since(r.start) > time.Minute {
+		// Running for more than a minute. This should never happen.
+		return nil, mem, r.errorAt(fn.blocks[0].instructions[0], fmt.Errorf("interp: running for more than a minute, timing out (executed calls: %d)", r.callsExecuted))
+	}
 
 	// Parameters are considered a kind of local values.
 	for i, param := range params {
@@ -103,13 +106,6 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 		}
 		switch inst.opcode {
 		case llvm.Ret:
-			const maxInterpSeconds = 180
-			if t0 > maxInterpSeconds*time.Second {
-				// Running for more than maxInterpSeconds seconds. This should never happen, but does.
-				// See github.com/tinygo-org/tinygo/issues/2124
-				return nil, mem, r.errorAt(fn.blocks[0].instructions[0], fmt.Errorf("interp: running for more than %d seconds, timing out (executed calls: %d)", maxInterpSeconds, r.callsExecuted))
-			}
-
 			if len(operands) != 0 {
 				if r.debug {
 					fmt.Fprintln(os.Stderr, indent+"ret", operands[0])
@@ -201,8 +197,7 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				// which case this call won't even get to this point but will
 				// already be emitted in initAll.
 				continue
-			case strings.HasPrefix(callFn.name, "runtime.print") || callFn.name == "runtime._panic" || callFn.name == "runtime.hashmapGet" ||
-				callFn.name == "os.runtime_args" || callFn.name == "internal/task.start" || callFn.name == "internal/task.Current":
+			case strings.HasPrefix(callFn.name, "runtime.print") || callFn.name == "runtime._panic" || callFn.name == "runtime.hashmapGet" || callFn.name == "os.runtime_args":
 				// These functions should be run at runtime. Specifically:
 				//   * Print and panic functions are best emitted directly without
 				//     interpreting them, otherwise we get a ton of putchar (etc.)
@@ -213,8 +208,6 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				//   * os.runtime_args reads globals that are initialized outside
 				//     the view of the interp package so it always needs to be run
 				//     at runtime.
-				//   * internal/task.start, internal/task.Current: start and read shcheduler state,
-				//     which is modified elsewhere.
 				err := r.runAtRuntime(fn, inst, locals, &mem, indent)
 				if err != nil {
 					return nil, mem, err
@@ -383,10 +376,6 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				if err != nil {
 					return nil, mem, r.errorAt(inst, err)
 				}
-				if !actualTypePtrToInt.IsAConstantInt().IsNil() && actualTypePtrToInt.ZExtValue() == 0 {
-					locals[inst.localIndex] = literalValue{uint8(0)}
-					break
-				}
 				actualType := actualTypePtrToInt.Operand(0)
 				if strings.TrimPrefix(actualType.Name(), "reflect/types.type:") == strings.TrimPrefix(assertedType.Name(), "reflect/types.typeid:") {
 					locals[inst.localIndex] = literalValue{uint8(1)}
@@ -444,7 +433,7 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				}
 
 				// Load the type code of the interface value.
-				typecodeIDBitCast, err := operands[len(operands)-2].toLLVMValue(inst.llvmInst.Operand(len(operands)-3).Type(), &mem)
+				typecodeIDBitCast, err := operands[len(operands)-3].toLLVMValue(inst.llvmInst.Operand(len(operands)-4).Type(), &mem)
 				if err != nil {
 					return nil, mem, r.errorAt(inst, err)
 				}
@@ -492,7 +481,7 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				// Call a function with a definition available. Run it as usual,
 				// possibly trying to recover from it if it failed to execute.
 				if r.debug {
-					argStrings := make([]string, len(operands))
+					argStrings := make([]string, len(operands)-1)
 					for i := range argStrings {
 						argStrings[i] = operands[i+1].String()
 					}
@@ -532,7 +521,7 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				return nil, mem, r.errorAt(inst, err)
 			}
 			size := operands[1].(literalValue).value.(uint64)
-			if inst.llvmInst.IsVolatile() || inst.llvmInst.Ordering() != llvm.AtomicOrderingNotAtomic || mem.hasExternalStore(ptr) {
+			if mem.hasExternalStore(ptr) {
 				// If there could be an external store (for example, because a
 				// pointer to the object was passed to a function that could not
 				// be interpreted at compile time) then the load must be done at
@@ -562,7 +551,7 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 			if err != nil {
 				return nil, mem, r.errorAt(inst, err)
 			}
-			if inst.llvmInst.IsVolatile() || inst.llvmInst.Ordering() != llvm.AtomicOrderingNotAtomic || mem.hasExternalLoadOrStore(ptr) {
+			if mem.hasExternalLoadOrStore(ptr) {
 				err := r.runAtRuntime(fn, inst, locals, &mem, indent)
 				if err != nil {
 					return nil, mem, err
@@ -936,18 +925,12 @@ func (r *runner) runAtRuntime(fn *function, inst instruction, locals []value, me
 		if inst.llvmInst.IsVolatile() {
 			result.SetVolatile(true)
 		}
-		if ordering := inst.llvmInst.Ordering(); ordering != llvm.AtomicOrderingNotAtomic {
-			result.SetOrdering(ordering)
-		}
 	case llvm.Store:
 		mem.markExternalStore(operands[1])
 		result = r.builder.CreateStore(operands[0], operands[1])
 		if inst.llvmInst.IsVolatile() {
 			result.SetVolatile(true)
 		}
-		if ordering := inst.llvmInst.Ordering(); ordering != llvm.AtomicOrderingNotAtomic {
-			result.SetOrdering(ordering)
-		}
 	case llvm.BitCast:
 		result = r.builder.CreateBitCast(operands[0], inst.llvmInst.Type(), inst.name)
 	case llvm.ExtractValue:

interp/memory.go

@@ -903,14 +903,7 @@ func (v rawValue) toLLVMValue(llvmType llvm.Type, mem *memoryView) (llvm.Value,
 				return llvm.Value{}, err
 			}
 			if llvmValue.Type() != llvmType {
-				if llvmValue.Type().PointerAddressSpace() != llvmType.PointerAddressSpace() {
-					// Special case for AVR function pointers.
-					// Because go-llvm doesn't have addrspacecast at the moment,
-					// do it indirectly with a ptrtoint/inttoptr pair.
-					llvmValue = llvm.ConstIntToPtr(llvm.ConstPtrToInt(llvmValue, mem.r.uintptrType), llvmType)
-				} else {
-					llvmValue = llvm.ConstBitCast(llvmValue, llvmType)
-				}
+				llvmValue = llvm.ConstBitCast(llvmValue, llvmType)
 			}
 			return llvmValue, nil
 		}

interp/testdata/interface.ll

@@ -5,7 +5,6 @@ target triple = "x86_64--linux"
 %runtime.interfaceMethodInfo = type { i8*, i64 }
 
 @main.v1 = global i1 0
-@main.v2 = global i1 0
 @"reflect/types.type:named:main.foo" = private constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:basic:int", i64 0, %runtime.interfaceMethodInfo* null }
 @"reflect/types.typeid:named:main.foo" = external constant i8
 @"reflect/types.type:basic:int" = external constant %runtime.typecodeID
@@ -24,7 +23,5 @@ entry:
   ; Test type asserts.
   %typecode = call i1 @runtime.typeAssert(i64 ptrtoint (%runtime.typecodeID* @"reflect/types.type:named:main.foo" to i64), i8* @"reflect/types.typeid:named:main.foo", i8* undef, i8* null)
   store i1 %typecode, i1* @main.v1
-  %typecode2 = call i1 @runtime.typeAssert(i64 0, i8* @"reflect/types.typeid:named:main.foo", i8* undef, i8* null)
-  store i1 %typecode2, i1* @main.v2
   ret void
 }

interp/testdata/interface.out.ll

@@ -2,7 +2,6 @@ target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64--linux"
 
 @main.v1 = local_unnamed_addr global i1 true
-@main.v2 = local_unnamed_addr global i1 false
 
 define void @runtime.initAll() unnamed_addr {
 entry:

interp/testdata/revert.ll

@@ -7,33 +7,28 @@ declare void @externalCall(i64)
 @bar.knownAtRuntime = global i64 0
 @baz.someGlobal = external global [3 x {i64, i32}]
 @baz.someInt = global i32 0
-@x.atomicNum = global i32 0
-@x.volatileNum = global i32 0
-@y.ready = global i32 0
 
 define void @runtime.initAll() unnamed_addr {
 entry:
-  call void @baz.init(i8* undef)
-  call void @foo.init(i8* undef)
-  call void @bar.init(i8* undef)
-  call void @main.init(i8* undef)
-  call void @x.init(i8* undef)
-  call void @y.init(i8* undef)
+  call void @baz.init(i8* undef, i8* undef)
+  call void @foo.init(i8* undef, i8* undef)
+  call void @bar.init(i8* undef, i8* undef)
+  call void @main.init(i8* undef, i8* undef)
   ret void
 }
 
-define internal void @foo.init(i8* %context) unnamed_addr {
+define internal void @foo.init(i8* %context, i8* %parentHandle) unnamed_addr {
   store i64 5, i64* @foo.knownAtRuntime
   unreachable ; this triggers a revert of @foo.init.
 }
 
-define internal void @bar.init(i8* %context) unnamed_addr {
+define internal void @bar.init(i8* %context, i8* %parentHandle) unnamed_addr {
   %val = load i64, i64* @foo.knownAtRuntime
   store i64 %val, i64* @bar.knownAtRuntime
   ret void
 }
 
-define internal void @baz.init(i8* %context) unnamed_addr {
+define internal void @baz.init(i8* %context, i8* %parentHandle) unnamed_addr {
   ; Test extractvalue/insertvalue with more than one index.
   %val = load [3 x {i64, i32}], [3 x {i64, i32}]* @baz.someGlobal
   %part = extractvalue [3 x {i64, i32}] %val, 0, 1
@@ -41,34 +36,8 @@ define internal void @baz.init(i8* %context) unnamed_addr {
   unreachable ; trigger revert
 }
 
-define internal void @main.init(i8* %context) unnamed_addr {
+define internal void @main.init(i8* %context, i8* %parentHandle) unnamed_addr {
 entry:
   call void @externalCall(i64 3)
   ret void
 }
-
-
-define internal void @x.init(i8* %context) unnamed_addr {
-  ; Test atomic and volatile memory accesses.
-  store atomic i32 1, i32* @x.atomicNum seq_cst, align 4
-  %x = load atomic i32, i32* @x.atomicNum seq_cst, align 4
-  store i32 %x, i32* @x.atomicNum
-  %y = load volatile i32, i32* @x.volatileNum
-  store volatile i32 %y, i32* @x.volatileNum
-  ret void
-}
-
-define internal void @y.init(i8* %context) unnamed_addr {
-entry:
-  br label %loop
-
-loop:
-  ; Test a wait-loop.
-  ; This function must be reverted.
-  %val = load atomic i32, i32* @y.ready seq_cst, align 4
-  %ready = icmp eq i32 %val, 1
-  br i1 %ready, label %end, label %loop
-
-end:
-  ret void
-}

interp/testdata/revert.out.ll

@@ -5,46 +5,24 @@ target triple = "x86_64--linux"
 @bar.knownAtRuntime = local_unnamed_addr global i64 0
 @baz.someGlobal = external local_unnamed_addr global [3 x { i64, i32 }]
 @baz.someInt = local_unnamed_addr global i32 0
-@x.atomicNum = local_unnamed_addr global i32 0
-@x.volatileNum = global i32 0
-@y.ready = local_unnamed_addr global i32 0
 
 declare void @externalCall(i64) local_unnamed_addr
 
 define void @runtime.initAll() unnamed_addr {
 entry:
-  call fastcc void @baz.init(i8* undef)
-  call fastcc void @foo.init(i8* undef)
+  call fastcc void @baz.init(i8* undef, i8* undef)
+  call fastcc void @foo.init(i8* undef, i8* undef)
   %val = load i64, i64* @foo.knownAtRuntime, align 8
   store i64 %val, i64* @bar.knownAtRuntime, align 8
   call void @externalCall(i64 3)
-  store atomic i32 1, i32* @x.atomicNum seq_cst, align 4
-  %x = load atomic i32, i32* @x.atomicNum seq_cst, align 4
-  store i32 %x, i32* @x.atomicNum, align 4
-  %y = load volatile i32, i32* @x.volatileNum, align 4
-  store volatile i32 %y, i32* @x.volatileNum, align 4
-  call fastcc void @y.init(i8* undef)
   ret void
 }
 
-define internal fastcc void @foo.init(i8* %context) unnamed_addr {
+define internal fastcc void @foo.init(i8* %context, i8* %parentHandle) unnamed_addr {
   store i64 5, i64* @foo.knownAtRuntime, align 8
   unreachable
 }
 
-define internal fastcc void @baz.init(i8* %context) unnamed_addr {
+define internal fastcc void @baz.init(i8* %context, i8* %parentHandle) unnamed_addr {
   unreachable
 }
-
-define internal fastcc void @y.init(i8* %context) unnamed_addr {
-entry:
-  br label %loop
-
-loop:                                             ; preds = %loop, %entry
-  %val = load atomic i32, i32* @y.ready seq_cst, align 4
-  %ready = icmp eq i32 %val, 1
-  br i1 %ready, label %end, label %loop
-
-end:                                              ; preds = %loop
-  ret void
-}

loader/goroot.go

@@ -14,8 +14,8 @@ package loader
 import (
 	"crypto/sha512"
 	"encoding/hex"
-	"encoding/json"
 	"errors"
+	"fmt"
 	"io"
 	"io/ioutil"
 	"os"
@@ -23,7 +23,6 @@ import (
 	"path"
 	"path/filepath"
 	"runtime"
-	"sort"
 	"sync"
 
 	"github.com/tinygo-org/tinygo/compileopts"
@@ -44,21 +43,27 @@ func GetCachedGoroot(config *compileopts.Config) (string, error) {
 		return "", errors.New("could not determine TINYGOROOT")
 	}
 
-	// Find the overrides needed for the goroot.
-	overrides := pathsToOverride(needsSyscallPackage(config.BuildTags()))
-
-	// Resolve the merge links within the goroot.
-	merge, err := listGorootMergeLinks(goroot, tinygoroot, overrides)
+	// Determine the location of the cached GOROOT.
+	version, err := goenv.GorootVersionString(goroot)
 	if err != nil {
 		return "", err
 	}
-
-	// Hash the merge links to create a cache key.
-	data, err := json.Marshal(merge)
-	if err != nil {
-		return "", err
+	// This hash is really a cache key, that contains (hopefully) enough
+	// information to make collisions unlikely during development.
+	// By including the Go version and TinyGo version, cache collisions should
+	// not happen outside of development.
+	hash := sha512.New512_256()
+	fmt.Fprintln(hash, goroot)
+	fmt.Fprintln(hash, version)
+	fmt.Fprintln(hash, goenv.Version)
+	fmt.Fprintln(hash, tinygoroot)
+	gorootsHash := hash.Sum(nil)
+	gorootsHashHex := hex.EncodeToString(gorootsHash[:])
+	cachedgorootName := "goroot-" + version + "-" + gorootsHashHex
+	cachedgoroot := filepath.Join(goenv.Get("GOCACHE"), cachedgorootName)
+	if needsSyscallPackage(config.BuildTags()) {
+		cachedgoroot += "-syscall"
 	}
-	hash := sha512.Sum512_256(data)
 
 	// Do not try to create the cached GOROOT in parallel, that's only a waste
 	// of I/O bandwidth and thus speed. Instead, use a mutex to make sure only
@@ -69,21 +74,14 @@ func GetCachedGoroot(config *compileopts.Config) (string, error) {
 	gorootCreateMutex.Lock()
 	defer gorootCreateMutex.Unlock()
 
-	// Check if the goroot already exists.
-	cachedGorootName := "goroot-" + hex.EncodeToString(hash[:])
-	cachedgoroot := filepath.Join(goenv.Get("GOCACHE"), cachedGorootName)
 	if _, err := os.Stat(cachedgoroot); err == nil {
 		return cachedgoroot, nil
 	}
-
-	// Create the cache directory if it does not already exist.
 	err = os.MkdirAll(goenv.Get("GOCACHE"), 0777)
 	if err != nil {
 		return "", err
 	}
-
-	// Create a temporary directory to construct the goroot within.
-	tmpgoroot, err := ioutil.TempDir(goenv.Get("GOCACHE"), cachedGorootName+".tmp")
+	tmpgoroot, err := ioutil.TempDir(goenv.Get("GOCACHE"), cachedgorootName+".tmp")
 	if err != nil {
 		return "", err
 	}
@@ -92,34 +90,16 @@ func GetCachedGoroot(config *compileopts.Config) (string, error) {
 	// (for example, when there was an error).
 	defer os.RemoveAll(tmpgoroot)
 
-	// Create the directory structure.
-	// The directories are created in sorted order so that nested directories are created without extra work.
-	{
-		var dirs []string
-		for dir, merge := range overrides {
-			if merge {
-				dirs = append(dirs, filepath.Join(tmpgoroot, "src", dir))
-			}
-		}
-		sort.Strings(dirs)
-
-		for _, dir := range dirs {
-			err := os.Mkdir(dir, 0777)
-			if err != nil {
-				return "", err
-			}
-		}
-	}
-
-	// Create all symlinks.
-	for dst, src := range merge {
-		err := symlink(src, filepath.Join(tmpgoroot, dst))
+	for _, name := range []string{"bin", "lib", "pkg"} {
+		err = symlink(filepath.Join(goroot, name), filepath.Join(tmpgoroot, name))
 		if err != nil {
 			return "", err
 		}
 	}
-
-	// Rename the new merged gorooot into place.
+	err = mergeDirectory(goroot, tinygoroot, tmpgoroot, "", pathsToOverride(needsSyscallPackage(config.BuildTags())))
+	if err != nil {
+		return "", err
+	}
 	err = os.Rename(tmpgoroot, cachedgoroot)
 	if err != nil {
 		if os.IsExist(err) {
@@ -142,71 +122,86 @@ func GetCachedGoroot(config *compileopts.Config) (string, error) {
 	return cachedgoroot, nil
 }
 
-// listGorootMergeLinks searches goroot and tinygoroot for all symlinks that must be created within the merged goroot.
-func listGorootMergeLinks(goroot, tinygoroot string, overrides map[string]bool) (map[string]string, error) {
-	goSrc := filepath.Join(goroot, "src")
-	tinygoSrc := filepath.Join(tinygoroot, "src")
-	merges := make(map[string]string)
-	for dir, merge := range overrides {
-		if !merge {
-			// Use the TinyGo version.
-			merges[filepath.Join("src", dir)] = filepath.Join(tinygoSrc, dir)
-			continue
+// mergeDirectory merges two roots recursively. The tmpgoroot is the directory
+// that will be created by this call by either symlinking the directory from
+// goroot or tinygoroot, or by creating the directory and merging the contents.
+func mergeDirectory(goroot, tinygoroot, tmpgoroot, importPath string, overrides map[string]bool) error {
+	if mergeSubdirs, ok := overrides[importPath+"/"]; ok {
+		if !mergeSubdirs {
+			// This directory and all subdirectories should come from the TinyGo
+			// root, so simply make a symlink.
+			newname := filepath.Join(tmpgoroot, "src", importPath)
+			oldname := filepath.Join(tinygoroot, "src", importPath)
+			return symlink(oldname, newname)
 		}
 
-		// Add files from TinyGo.
-		tinygoDir := filepath.Join(tinygoSrc, dir)
-		tinygoEntries, err := ioutil.ReadDir(tinygoDir)
+		// Merge subdirectories. Start by making the directory to merge.
+		err := os.Mkdir(filepath.Join(tmpgoroot, "src", importPath), 0777)
 		if err != nil {
-			return nil, err
+			return err
 		}
-		var hasTinyGoFiles bool
+
+		// Symlink all files from TinyGo, and symlink directories from TinyGo
+		// that need to be overridden.
+		tinygoEntries, err := ioutil.ReadDir(filepath.Join(tinygoroot, "src", importPath))
+		if err != nil {
+			return err
+		}
+		hasTinyGoFiles := false
 		for _, e := range tinygoEntries {
 			if e.IsDir() {
-				continue
+				// A directory, so merge this thing.
+				err := mergeDirectory(goroot, tinygoroot, tmpgoroot, path.Join(importPath, e.Name()), overrides)
+				if err != nil {
+					return err
+				}
+			} else {
+				// A file, so symlink this.
+				newname := filepath.Join(tmpgoroot, "src", importPath, e.Name())
+				oldname := filepath.Join(tinygoroot, "src", importPath, e.Name())
+				err := symlink(oldname, newname)
+				if err != nil {
+					return err
+				}
+				hasTinyGoFiles = true
 			}
-
-			// Link this file.
-			name := e.Name()
-			merges[filepath.Join("src", dir, name)] = filepath.Join(tinygoDir, name)
-
-			hasTinyGoFiles = true
 		}
 
-		// Add all directories from $GOROOT that are not part of the TinyGo
+		// Symlink all directories from $GOROOT that are not part of the TinyGo
 		// overrides.
-		goDir := filepath.Join(goSrc, dir)
-		goEntries, err := ioutil.ReadDir(goDir)
+		gorootEntries, err := ioutil.ReadDir(filepath.Join(goroot, "src", importPath))
 		if err != nil {
-			return nil, err
+			return err
 		}
-		for _, e := range goEntries {
-			isDir := e.IsDir()
-			if hasTinyGoFiles && !isDir {
+		for _, e := range gorootEntries {
+			if e.IsDir() {
+				if _, ok := overrides[path.Join(importPath, e.Name())+"/"]; ok {
+					// Already included above, so don't bother trying to create this
+					// symlink.
+					continue
+				}
+				newname := filepath.Join(tmpgoroot, "src", importPath, e.Name())
+				oldname := filepath.Join(goroot, "src", importPath, e.Name())
+				err := symlink(oldname, newname)
+				if err != nil {
+					return err
+				}
+			} else {
 				// Only merge files from Go if TinyGo does not have any files.
 				// Otherwise we'd end up with a weird mix from both Go
 				// implementations.
-				continue
+				if !hasTinyGoFiles {
+					newname := filepath.Join(tmpgoroot, "src", importPath, e.Name())
+					oldname := filepath.Join(goroot, "src", importPath, e.Name())
+					err := symlink(oldname, newname)
+					if err != nil {
+						return err
+					}
+				}
 			}
-
-			name := e.Name()
-			if _, ok := overrides[path.Join(dir, name)+"/"]; ok {
-				// This entry is overridden by TinyGo.
-				// It has/will be merged elsewhere.
-				continue
-			}
-
-			// Add a link to this entry
-			merges[filepath.Join("src", dir, name)] = filepath.Join(goDir, name)
 		}
 	}
-
-	// Merge the special directories from goroot.
-	for _, dir := range []string{"bin", "lib", "pkg"} {
-		merges[dir] = filepath.Join(goroot, dir)
-	}
-
-	return merges, nil
+	return nil
 }
 
 // needsSyscallPackage returns whether the syscall package should be overriden
@@ -224,7 +219,7 @@ func needsSyscallPackage(buildTags []string) bool {
 // means use the TinyGo version.
 func pathsToOverride(needsSyscallPackage bool) map[string]bool {
 	paths := map[string]bool{
-		"":                      true,
+		"/":                     true,
 		"crypto/":               true,
 		"crypto/rand/":          false,
 		"device/":               false,

loader/list.go

@@ -3,11 +3,9 @@ package loader
 import (
 	"os"
 	"os/exec"
-	"path/filepath"
 	"strings"
 
 	"github.com/tinygo-org/tinygo/compileopts"
-	"github.com/tinygo-org/tinygo/goenv"
 )
 
 // List returns a ready-to-run *exec.Cmd for running the `go list` command with
@@ -26,10 +24,7 @@ func List(config *compileopts.Config, extraArgs, pkgs []string) (*exec.Cmd, erro
 	if config.CgoEnabled() {
 		cgoEnabled = "1"
 	}
-	cmd := exec.Command(filepath.Join(goenv.Get("GOROOT"), "bin", "go"), args...)
+	cmd := exec.Command("go", args...)
 	cmd.Env = append(os.Environ(), "GOROOT="+goroot, "GOOS="+config.GOOS(), "GOARCH="+config.GOARCH(), "CGO_ENABLED="+cgoEnabled)
-	if config.Options.Directory != "" {
-		cmd.Dir = config.Options.Directory
-	}
 	return cmd, nil
 }

loader/loader.go

@@ -47,14 +47,6 @@ type PackageJSON struct {
 	ImportPath string
 	Name       string
 	ForTest    string
-	Root       string
-	Module     struct {
-		Path      string
-		Main      bool
-		Dir       string
-		GoMod     string
-		GoVersion string
-	}
 
 	// Source files
 	GoFiles  []string
@@ -94,14 +86,9 @@ func Load(config *compileopts.Config, inputPkgs []string, clangHeaders string, t
 	if err != nil {
 		return nil, err
 	}
-	var wd string
-	if config.Options.Directory != "" {
-		wd = config.Options.Directory
-	} else {
-		wd, err = os.Getwd()
-		if err != nil {
-			return nil, err
-		}
+	wd, err := os.Getwd()
+	if err != nil {
+		return nil, err
 	}
 	p := &Program{
 		config:       config,
@@ -419,7 +406,7 @@ func (p *Package) parseFiles() ([]*ast.File, error) {
 		initialCFlags = append(initialCFlags, p.program.config.CFlags()...)
 		initialCFlags = append(initialCFlags, "-I"+p.Dir)
 		if p.program.clangHeaders != "" {
-			initialCFlags = append(initialCFlags, "-isystem", p.program.clangHeaders)
+			initialCFlags = append(initialCFlags, "-Xclang", "-internal-isystem", "-Xclang", p.program.clangHeaders)
 		}
 		generated, headerCode, cflags, ldflags, accessedFiles, errs := cgo.Process(files, p.program.workingDir, p.program.fset, initialCFlags)
 		p.CFlags = append(initialCFlags, cflags...)

main.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"bytes"
-	"encoding/json"
 	"errors"
 	"flag"
 	"fmt"
@@ -19,7 +18,6 @@ import (
 	"runtime/pprof"
 	"strconv"
 	"strings"
-	"sync"
 	"sync/atomic"
 	"time"
 
@@ -30,6 +28,7 @@ import (
 	"github.com/tinygo-org/tinygo/goenv"
 	"github.com/tinygo-org/tinygo/interp"
 	"github.com/tinygo-org/tinygo/loader"
+	"github.com/tinygo-org/tinygo/transform"
 	"tinygo.org/x/go-llvm"
 
 	"go.bug.st/serial"
@@ -178,14 +177,14 @@ func Build(pkgName, outpath string, options *compileopts.Options) error {
 
 // Test runs the tests in the given package. Returns whether the test passed and
 // possibly an error if the test failed to run.
-func Test(pkgName string, stdout, stderr io.Writer, options *compileopts.Options, testCompileOnly, testVerbose, testShort bool, testRunRegexp string, testBenchRegexp string, testBenchTime string, outpath string) (bool, error) {
+func Test(pkgName string, options *compileopts.Options, testCompileOnly, testVerbose, testShort bool, outpath string) (bool, error) {
 	options.TestConfig.CompileTestBinary = true
 	config, err := builder.NewConfig(options)
 	if err != nil {
 		return false, err
 	}
 
-	passed := false
+	passed := true
 	err = builder.Build(pkgName, outpath, config, func(result builder.BuildResult) error {
 		if testCompileOnly || outpath != "" {
 			// Write test binary to the specified file name.
@@ -198,18 +197,13 @@ func Test(pkgName string, stdout, stderr io.Writer, options *compileopts.Options
 		}
 		if testCompileOnly {
 			// Do not run the test.
-			passed = true
 			return nil
 		}
 
 		// Run the test.
-		config.Options.Semaphore <- struct{}{}
-		defer func() {
-			<-config.Options.Semaphore
-		}()
 		start := time.Now()
 		var err error
-		passed, err = runPackageTest(config, stdout, stderr, result, testVerbose, testShort, testRunRegexp, testBenchRegexp, testBenchTime)
+		passed, err = runPackageTest(config, result, testVerbose, testShort)
 		if err != nil {
 			return err
 		}
@@ -218,40 +212,26 @@ func Test(pkgName string, stdout, stderr io.Writer, options *compileopts.Options
 		// Print the result.
 		importPath := strings.TrimSuffix(result.ImportPath, ".test")
 		if passed {
-			fmt.Fprintf(stdout, "ok  \t%s\t%.3fs\n", importPath, duration.Seconds())
+			fmt.Printf("ok  \t%s\t%.3fs\n", importPath, duration.Seconds())
 		} else {
-			fmt.Fprintf(stdout, "FAIL\t%s\t%.3fs\n", importPath, duration.Seconds())
+			fmt.Printf("FAIL\t%s\t%.3fs\n", importPath, duration.Seconds())
 		}
 		return nil
 	})
 	if err, ok := err.(loader.NoTestFilesError); ok {
-		fmt.Fprintf(stdout, "?   \t%s\t[no test files]\n", err.ImportPath)
+		fmt.Printf("?   \t%s\t[no test files]\n", err.ImportPath)
 		// Pretend the test passed - it at least didn't fail.
 		return true, nil
 	}
 	return passed, err
 }
 
-func dirsToModuleRoot(maindir, modroot string) []string {
-	var dirs = []string{"."}
-	last := ".."
-	// strip off path elements until we hit the module root
-	// adding `..`, `../..`, `../../..` until we're done
-	for maindir != modroot {
-		dirs = append(dirs, last)
-		last = filepath.Join(last, "..")
-		maindir = filepath.Dir(maindir)
-	}
-	return dirs
-}
-
 // runPackageTest runs a test binary that was previously built. The return
 // values are whether the test passed and any errors encountered while trying to
 // run the binary.
-func runPackageTest(config *compileopts.Config, stdout, stderr io.Writer, result builder.BuildResult, testVerbose, testShort bool, testRunRegexp string, testBenchRegexp string, testBenchTime string) (bool, error) {
+func runPackageTest(config *compileopts.Config, result builder.BuildResult, testVerbose, testShort bool) (bool, error) {
 	var cmd *exec.Cmd
-	emulator := config.Emulator()
-	if len(emulator) == 0 {
+	if len(config.Target.Emulator) == 0 {
 		// Run directly.
 		var flags []string
 		if testVerbose {
@@ -260,54 +240,26 @@ func runPackageTest(config *compileopts.Config, stdout, stderr io.Writer, result
 		if testShort {
 			flags = append(flags, "-test.short")
 		}
-		if testRunRegexp != "" {
-			flags = append(flags, "-test.run="+testRunRegexp)
-		}
-		if testBenchRegexp != "" {
-			flags = append(flags, "-test.bench="+testBenchRegexp)
-		}
-		if testBenchTime != "" {
-			flags = append(flags, "-test.benchtime="+testBenchTime)
-		}
 		cmd = executeCommand(config.Options, result.Binary, flags...)
+		cmd.Dir = result.MainDir
 	} else {
 		// Run in an emulator.
-		args := append(emulator[1:], result.Binary)
-		if emulator[0] == "wasmtime" {
-			// create a new temp directory just for this run, announce it to os.TempDir() via TMPDIR
-			tmpdir, err := ioutil.TempDir("", "tinygotmp")
-			if err != nil {
-				return false, &commandError{"failed to create temporary directory", "tinygotmp", err}
-			}
-			args = append(args, "--dir="+tmpdir, "--env=TMPDIR="+tmpdir)
-			// TODO: add option to not delete temp dir for debugging?
-			defer os.RemoveAll(tmpdir)
-
-			// allow reading from directories up to module root
-			for _, d := range dirsToModuleRoot(result.MainDir, result.ModuleRoot) {
-				args = append(args, "--dir="+d)
-			}
-
+		args := append(config.Target.Emulator[1:], result.Binary)
+		if config.Target.Emulator[0] == "wasmtime" {
+			// allow reading from current directory: --dir=.
 			// mark end of wasmtime arguments and start of program ones: --
-			args = append(args, "--")
+			args = append(args, "--dir=.", "--")
 			if testVerbose {
 				args = append(args, "-test.v")
 			}
 			if testShort {
 				args = append(args, "-test.short")
 			}
-			if testRunRegexp != "" {
-				args = append(args, "-test.run="+testRunRegexp)
-			}
-			if testBenchRegexp != "" {
-				args = append(args, "-test.bench="+testBenchRegexp)
-			}
 		}
-		cmd = executeCommand(config.Options, emulator[0], args...)
+		cmd = executeCommand(config.Options, config.Target.Emulator[0], args...)
 	}
-	cmd.Dir = result.MainDir
-	cmd.Stdout = stdout
-	cmd.Stderr = stderr
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
 	err := cmd.Run()
 	if err != nil {
 		if _, ok := err.(*exec.ExitError); ok {
@@ -501,13 +453,12 @@ func Debug(debugger, pkgName string, ocdOutput bool, options *compileopts.Option
 		gdbInterface, openocdInterface := config.Programmer()
 		switch gdbInterface {
 		case "msd", "command", "":
-			emulator := config.Emulator()
-			if len(emulator) != 0 {
-				if emulator[0] == "mgba" {
+			if len(config.Target.Emulator) != 0 {
+				if config.Target.Emulator[0] == "mgba" {
 					gdbInterface = "mgba"
-				} else if emulator[0] == "simavr" {
+				} else if config.Target.Emulator[0] == "simavr" {
 					gdbInterface = "simavr"
-				} else if strings.HasPrefix(emulator[0], "qemu-system-") {
+				} else if strings.HasPrefix(config.Target.Emulator[0], "qemu-system-") {
 					gdbInterface = "qemu"
 				} else {
 					// Assume QEMU as an emulator.
@@ -575,34 +526,34 @@ func Debug(debugger, pkgName string, ocdOutput bool, options *compileopts.Option
 			}
 		case "qemu":
 			port = ":1234"
-			emulator := config.Emulator()
+
 			// Run in an emulator.
-			args := append(emulator[1:], result.Binary, "-s", "-S")
-			daemon = executeCommand(config.Options, emulator[0], args...)
+			args := append(config.Target.Emulator[1:], result.Binary, "-s", "-S")
+			daemon = executeCommand(config.Options, config.Target.Emulator[0], args...)
 			daemon.Stdout = os.Stdout
 			daemon.Stderr = os.Stderr
 		case "qemu-user":
 			port = ":1234"
-			emulator := config.Emulator()
+
 			// Run in an emulator.
-			args := append(emulator[1:], "-g", "1234", result.Binary)
-			daemon = executeCommand(config.Options, emulator[0], args...)
+			args := append(config.Target.Emulator[1:], "-g", "1234", result.Binary)
+			daemon = executeCommand(config.Options, config.Target.Emulator[0], args...)
 			daemon.Stdout = os.Stdout
 			daemon.Stderr = os.Stderr
 		case "mgba":
 			port = ":2345"
-			emulator := config.Emulator()
+
 			// Run in an emulator.
-			args := append(emulator[1:], result.Binary, "-g")
-			daemon = executeCommand(config.Options, emulator[0], args...)
+			args := append(config.Target.Emulator[1:], result.Binary, "-g")
+			daemon = executeCommand(config.Options, config.Target.Emulator[0], args...)
 			daemon.Stdout = os.Stdout
 			daemon.Stderr = os.Stderr
 		case "simavr":
 			port = ":1234"
-			emulator := config.Emulator()
+
 			// Run in an emulator.
-			args := append(emulator[1:], "-g", result.Binary)
-			daemon = executeCommand(config.Options, emulator[0], args...)
+			args := append(config.Target.Emulator[1:], "-g", result.Binary)
+			daemon = executeCommand(config.Options, config.Target.Emulator[0], args...)
 			daemon.Stdout = os.Stdout
 			daemon.Stderr = os.Stderr
 		case "msd":
@@ -697,8 +648,7 @@ func Run(pkgName string, options *compileopts.Options) error {
 	}
 
 	return builder.Build(pkgName, ".elf", config, func(result builder.BuildResult) error {
-		emulator := config.Emulator()
-		if len(emulator) == 0 {
+		if len(config.Target.Emulator) == 0 {
 			// Run directly.
 			cmd := executeCommand(config.Options, result.Binary)
 			cmd.Stdout = os.Stdout
@@ -714,8 +664,8 @@ func Run(pkgName string, options *compileopts.Options) error {
 			return nil
 		} else {
 			// Run in an emulator.
-			args := append(emulator[1:], result.Binary)
-			cmd := executeCommand(config.Options, emulator[0], args...)
+			args := append(config.Target.Emulator[1:], result.Binary)
+			cmd := executeCommand(config.Options, config.Target.Emulator[0], args...)
 			cmd.Stdout = os.Stdout
 			cmd.Stderr = os.Stderr
 			err := cmd.Run()
@@ -763,12 +713,7 @@ func flashUF2UsingMSD(volume, tmppath string, options *compileopts.Options) erro
 	var infoPath string
 	switch runtime.GOOS {
 	case "linux", "freebsd":
-		fi, err := os.Stat("/run/media")
-		if err != nil || !fi.IsDir() {
-			infoPath = "/media/*/" + volume + "/INFO_UF2.TXT"
-		} else {
-			infoPath = "/run/media/*/" + volume + "/INFO_UF2.TXT"
-		}
+		infoPath = "/media/*/" + volume + "/INFO_UF2.TXT"
 	case "darwin":
 		infoPath = "/Volumes/" + volume + "/INFO_UF2.TXT"
 	case "windows":
@@ -792,12 +737,7 @@ func flashHexUsingMSD(volume, tmppath string, options *compileopts.Options) erro
 	var destPath string
 	switch runtime.GOOS {
 	case "linux", "freebsd":
-		fi, err := os.Stat("/run/media")
-		if err != nil || !fi.IsDir() {
-			destPath = "/media/*/" + volume
-		} else {
-			destPath = "/run/media/*/" + volume
-		}
+		destPath = "/media/*/" + volume
 	case "darwin":
 		destPath = "/Volumes/" + volume
 	case "windows":
@@ -1010,39 +950,22 @@ func getBMPPorts() (gdbPort, uartPort string, err error) {
 	}
 }
 
-func usage(command string) {
-	version := goenv.Version
-	if strings.HasSuffix(version, "-dev") && gitSha1 != "" {
-		version += "-" + gitSha1
-	}
-
-	switch command {
-	default:
-		fmt.Fprintln(os.Stderr, "TinyGo is a Go compiler for small places.")
-		fmt.Fprintln(os.Stderr, "version:", version)
-		fmt.Fprintf(os.Stderr, "usage: %s <command> [arguments]\n", os.Args[0])
-		fmt.Fprintln(os.Stderr, "\ncommands:")
-		fmt.Fprintln(os.Stderr, "  build:   compile packages and dependencies")
-		fmt.Fprintln(os.Stderr, "  run:     compile and run immediately")
-		fmt.Fprintln(os.Stderr, "  test:    test packages")
-		fmt.Fprintln(os.Stderr, "  flash:   compile and flash to the device")
-		fmt.Fprintln(os.Stderr, "  gdb:     run/flash and immediately enter GDB")
-		fmt.Fprintln(os.Stderr, "  lldb:    run/flash and immediately enter LLDB")
-		fmt.Fprintln(os.Stderr, "  env:     list environment variables used during build")
-		fmt.Fprintln(os.Stderr, "  list:    run go list using the TinyGo root")
-		fmt.Fprintln(os.Stderr, "  clean:   empty cache directory ("+goenv.Get("GOCACHE")+")")
-		fmt.Fprintln(os.Stderr, "  targets: list targets")
-		fmt.Fprintln(os.Stderr, "  info:    show info for specified target")
-		fmt.Fprintln(os.Stderr, "  version: show version")
-		fmt.Fprintln(os.Stderr, "  help:    print this help text")
-
-		if flag.Parsed() {
-			fmt.Fprintln(os.Stderr, "\nflags:")
-			flag.PrintDefaults()
-		}
-
-		fmt.Fprintln(os.Stderr, "\nfor more details, see https://tinygo.org/docs/reference/usage/")
-	}
+func usage() {
+	fmt.Fprintln(os.Stderr, "TinyGo is a Go compiler for small places.")
+	fmt.Fprintln(os.Stderr, "version:", goenv.Version)
+	fmt.Fprintf(os.Stderr, "usage: %s command [-printir] [-target=<target>] -o <output> <input>\n", os.Args[0])
+	fmt.Fprintln(os.Stderr, "\ncommands:")
+	fmt.Fprintln(os.Stderr, "  build: compile packages and dependencies")
+	fmt.Fprintln(os.Stderr, "  run:   compile and run immediately")
+	fmt.Fprintln(os.Stderr, "  test:  test packages")
+	fmt.Fprintln(os.Stderr, "  flash: compile and flash to the device")
+	fmt.Fprintln(os.Stderr, "  gdb:   run/flash and immediately enter GDB")
+	fmt.Fprintln(os.Stderr, "  env:   list environment variables used during build")
+	fmt.Fprintln(os.Stderr, "  list:  run go list using the TinyGo root")
+	fmt.Fprintln(os.Stderr, "  clean: empty cache directory ("+goenv.Get("GOCACHE")+")")
+	fmt.Fprintln(os.Stderr, "  help:  print this help text")
+	fmt.Fprintln(os.Stderr, "\nflags:")
+	flag.PrintDefaults()
 }
 
 // try to make the path relative to the current working directory. If any error
@@ -1099,6 +1022,15 @@ func printCompilerError(logln func(...interface{}), err error) {
 				logln()
 			}
 		}
+	case transform.CoroutinesError:
+		logln(err.Pos.String() + ": " + err.Msg)
+		logln("\ntraceback:")
+		for _, line := range err.Traceback {
+			logln(line.Name)
+			if line.Position.IsValid() {
+				logln("\t" + line.Position.String())
+			}
+		}
 	case loader.Errors:
 		logln("#", err.Pkg.ImportPath)
 		for _, err := range err.Errs {
@@ -1177,15 +1109,15 @@ func parseGoLinkFlag(flagsString string) (map[string]map[string]string, error) {
 func main() {
 	if len(os.Args) < 2 {
 		fmt.Fprintln(os.Stderr, "No command-line arguments supplied.")
-		usage("")
+		usage()
 		os.Exit(1)
 	}
 	command := os.Args[1]
 
 	opt := flag.String("opt", "z", "optimization level: 0, 1, 2, s, z")
-	gc := flag.String("gc", "", "garbage collector to use (none, leaking, conservative)")
+	gc := flag.String("gc", "", "garbage collector to use (none, leaking, extalloc, conservative)")
 	panicStrategy := flag.String("panic", "print", "panic strategy (print, trap)")
-	scheduler := flag.String("scheduler", "", "which scheduler to use (none, tasks, asyncify)")
+	scheduler := flag.String("scheduler", "", "which scheduler to use (none, coroutines, tasks)")
 	serial := flag.String("serial", "", "which serial output to use (none, uart, usb)")
 	printIR := flag.Bool("printir", false, "print LLVM IR")
 	dumpSSA := flag.Bool("dumpssa", false, "dump internal Go SSA")
@@ -1208,10 +1140,8 @@ func main() {
 	cpuprofile := flag.String("cpuprofile", "", "cpuprofile output")
 
 	var flagJSON, flagDeps, flagTest *bool
-	if command == "help" || command == "list" || command == "info" {
-		flagJSON = flag.Bool("json", false, "print data in JSON format")
-	}
 	if command == "help" || command == "list" {
+		flagJSON = flag.Bool("json", false, "print data in JSON format")
 		flagDeps = flag.Bool("deps", false, "supply -deps flag to go list")
 		flagTest = flag.Bool("test", false, "supply -test flag to go list")
 	}
@@ -1220,16 +1150,10 @@ func main() {
 		flag.StringVar(&outpath, "o", "", "output filename")
 	}
 	var testCompileOnlyFlag, testVerboseFlag, testShortFlag *bool
-	var testBenchRegexp *string
-	var testBenchTime *string
-	var testRunRegexp *string
 	if command == "help" || command == "test" {
 		testCompileOnlyFlag = flag.Bool("c", false, "compile the test binary but do not run it")
 		testVerboseFlag = flag.Bool("v", false, "verbose: print additional output")
 		testShortFlag = flag.Bool("short", false, "short: run smaller test suite to save time")
-		testRunRegexp = flag.String("run", "", "run: regexp of tests to run")
-		testBenchRegexp = flag.String("bench", "", "run: regexp of benchmarks to run")
-		testBenchTime = flag.String("benchtime", "", "run each benchmark for duration `d`")
 	}
 
 	// Early command processing, before commands are interpreted by the Go flag
@@ -1278,7 +1202,7 @@ func main() {
 		PrintIR:         *printIR,
 		DumpSSA:         *dumpSSA,
 		VerifyIR:        *verifyIR,
-		Semaphore:       make(chan struct{}, *parallelism),
+		Parallelism:     *parallelism,
 		Debug:           !*nodebug,
 		PrintSizes:      *printSize,
 		PrintStacks:     *printStacks,
@@ -1297,7 +1221,7 @@ func main() {
 	err = options.Verify()
 	if err != nil {
 		fmt.Fprintln(os.Stderr, err.Error())
-		usage(command)
+		usage()
 		os.Exit(1)
 	}
 
@@ -1319,7 +1243,7 @@ func main() {
 	case "build":
 		if outpath == "" {
 			fmt.Fprintln(os.Stderr, "No output filename supplied (-o).")
-			usage(command)
+			usage()
 			os.Exit(1)
 		}
 		pkgName := "."
@@ -1327,7 +1251,7 @@ func main() {
 			pkgName = filepath.ToSlash(flag.Arg(0))
 		} else if flag.NArg() > 1 {
 			fmt.Fprintln(os.Stderr, "build only accepts a single positional argument: package name, but multiple were specified")
-			usage(command)
+			usage()
 			os.Exit(1)
 		}
 		if options.Target == "" && filepath.Ext(outpath) == ".wasm" {
@@ -1340,7 +1264,7 @@ func main() {
 		// Note: this command is only meant to be used while making a release!
 		if outpath == "" {
 			fmt.Fprintln(os.Stderr, "No output filename supplied (-o).")
-			usage(command)
+			usage()
 			os.Exit(1)
 		}
 		if *target == "" {
@@ -1348,7 +1272,7 @@ func main() {
 		}
 		if flag.NArg() != 1 {
 			fmt.Fprintf(os.Stderr, "Build-library only accepts exactly one library name as argument, %d given\n", flag.NArg())
-			usage(command)
+			usage()
 			os.Exit(1)
 		}
 		var lib *builder.Library
@@ -1366,13 +1290,11 @@ func main() {
 			handleCompilerError(err)
 		}
 		defer os.RemoveAll(tmpdir)
-		spec, err := compileopts.LoadTarget(options)
-		if err != nil {
-			handleCompilerError(err)
-		}
 		config := &compileopts.Config{
 			Options: options,
-			Target:  spec,
+			Target: &compileopts.TargetSpec{
+				Triple: *target,
+			},
 		}
 		path, err := lib.Load(config, tmpdir)
 		handleCompilerError(err)
@@ -1388,7 +1310,7 @@ func main() {
 		} else {
 			if !options.Debug {
 				fmt.Fprintln(os.Stderr, "Debug disabled while running debugger?")
-				usage(command)
+				usage()
 				os.Exit(1)
 			}
 			err := Debug(command, pkgName, *ocdOutput, options)
@@ -1397,7 +1319,7 @@ func main() {
 	case "run":
 		if flag.NArg() != 1 {
 			fmt.Fprintln(os.Stderr, "No package specified.")
-			usage(command)
+			usage()
 			os.Exit(1)
 		}
 		pkgName := filepath.ToSlash(flag.Arg(0))
@@ -1411,69 +1333,16 @@ func main() {
 		if len(pkgNames) == 0 {
 			pkgNames = []string{"."}
 		}
-		if *testCompileOnlyFlag && len(pkgNames) > 1 {
-			fmt.Println("cannot use -c flag with multiple packages")
-			os.Exit(1)
-		}
-
-		fail := make(chan struct{}, 1)
-		var wg sync.WaitGroup
-		bufs := make([]testOutputBuf, len(pkgNames))
-		for i := range bufs {
-			bufs[i].done = make(chan struct{})
-		}
-
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-
-			// Flush the output one test at a time.
-			// This ensures that outputs from different tests are not mixed together.
-			for i := range bufs {
-				err := bufs[i].flush(os.Stdout, os.Stderr)
-				if err != nil {
-					// There was an error writing to stdout or stderr, so we probbably cannot print this.
-					select {
-					case fail <- struct{}{}:
-					default:
-					}
-				}
+		allTestsPassed := true
+		for _, pkgName := range pkgNames {
+			// TODO: parallelize building the test binaries
+			passed, err := Test(pkgName, options, *testCompileOnlyFlag, *testVerboseFlag, *testShortFlag, outpath)
+			handleCompilerError(err)
+			if !passed {
+				allTestsPassed = false
 			}
-		}()
-
-		// Build and run the tests concurrently.
-		// This uses an additional semaphore to reduce the memory usage.
-		testSema := make(chan struct{}, cap(options.Semaphore))
-		for i, pkgName := range pkgNames {
-			pkgName := pkgName
-			buf := &bufs[i]
-			testSema <- struct{}{}
-			wg.Add(1)
-			go func() {
-				defer wg.Done()
-				defer func() { <-testSema }()
-				defer close(buf.done)
-				stdout := (*testStdout)(buf)
-				stderr := (*testStderr)(buf)
-				passed, err := Test(pkgName, stdout, stderr, options, *testCompileOnlyFlag, *testVerboseFlag, *testShortFlag, *testRunRegexp, *testBenchRegexp, *testBenchTime, outpath)
-				if err != nil {
-					printCompilerError(func(args ...interface{}) {
-						fmt.Fprintln(stderr, args...)
-					}, err)
-				}
-				if !passed {
-					select {
-					case fail <- struct{}{}:
-					default:
-					}
-				}
-			}()
 		}
-
-		// Wait for all tests to finish.
-		wg.Wait()
-		close(fail)
-		if _, fail := <-fail; fail {
+		if !allTestsPassed {
 			fmt.Println("FAIL")
 			os.Exit(1)
 		}
@@ -1511,13 +1380,13 @@ func main() {
 			options.Target = flag.Arg(0)
 		} else if flag.NArg() > 1 {
 			fmt.Fprintln(os.Stderr, "only one target name is accepted")
-			usage(command)
+			usage()
 			os.Exit(1)
 		}
 		config, err := builder.NewConfig(options)
 		if err != nil {
 			fmt.Fprintln(os.Stderr, err)
-			usage(command)
+			usage()
 			os.Exit(1)
 		}
 		config.GoMinorVersion = 0 // this avoids creating the list of Go1.x build tags.
@@ -1530,42 +1399,19 @@ func main() {
 			fmt.Fprintln(os.Stderr, err)
 			os.Exit(1)
 		}
-		if *flagJSON {
-			json, _ := json.MarshalIndent(struct {
-				GOROOT     string   `json:"goroot"`
-				GOOS       string   `json:"goos"`
-				GOARCH     string   `json:"goarch"`
-				GOARM      string   `json:"goarm"`
-				BuildTags  []string `json:"build_tags"`
-				GC         string   `json:"garbage_collector"`
-				Scheduler  string   `json:"scheduler"`
-				LLVMTriple string   `json:"llvm_triple"`
-			}{
-				GOROOT:     cachedGOROOT,
-				GOOS:       config.GOOS(),
-				GOARCH:     config.GOARCH(),
-				GOARM:      config.GOARM(),
-				BuildTags:  config.BuildTags(),
-				GC:         config.GC(),
-				Scheduler:  config.Scheduler(),
-				LLVMTriple: config.Triple(),
-			}, "", "  ")
-			fmt.Println(string(json))
-		} else {
-			fmt.Printf("LLVM triple:       %s\n", config.Triple())
-			fmt.Printf("GOOS:              %s\n", config.GOOS())
-			fmt.Printf("GOARCH:            %s\n", config.GOARCH())
-			fmt.Printf("GOARM:             %s\n", config.GOARM())
-			fmt.Printf("build tags:        %s\n", strings.Join(config.BuildTags(), " "))
-			fmt.Printf("garbage collector: %s\n", config.GC())
-			fmt.Printf("scheduler:         %s\n", config.Scheduler())
-			fmt.Printf("cached GOROOT:     %s\n", cachedGOROOT)
-		}
+		fmt.Printf("LLVM triple:       %s\n", config.Triple())
+		fmt.Printf("GOOS:              %s\n", config.GOOS())
+		fmt.Printf("GOARCH:            %s\n", config.GOARCH())
+		fmt.Printf("GOARM:             %s\n", config.GOARM())
+		fmt.Printf("build tags:        %s\n", strings.Join(config.BuildTags(), " "))
+		fmt.Printf("garbage collector: %s\n", config.GC())
+		fmt.Printf("scheduler:         %s\n", config.Scheduler())
+		fmt.Printf("cached GOROOT:     %s\n", cachedGOROOT)
 	case "list":
 		config, err := builder.NewConfig(options)
 		if err != nil {
 			fmt.Fprintln(os.Stderr, err)
-			usage(command)
+			usage()
 			os.Exit(1)
 		}
 		var extraArgs []string
@@ -1601,11 +1447,7 @@ func main() {
 			os.Exit(1)
 		}
 	case "help":
-		command := ""
-		if flag.NArg() >= 1 {
-			command = flag.Arg(0)
-		}
-		usage(command)
+		usage()
 	case "version":
 		goversion := "<unknown>"
 		if s, err := goenv.GorootVersionString(goenv.Get("GOROOT")); err == nil {
@@ -1630,121 +1472,7 @@ func main() {
 		}
 	default:
 		fmt.Fprintln(os.Stderr, "Unknown command:", command)
-		usage("")
+		usage()
 		os.Exit(1)
 	}
 }
-
-// testOutputBuf is used to buffer the output of concurrent tests.
-type testOutputBuf struct {
-	mu             sync.Mutex
-	output         []outputEntry
-	stdout, stderr io.Writer
-	outerr, errerr error
-	done           chan struct{}
-}
-
-// flush the output to stdout and stderr.
-// This waits until done is closed.
-func (b *testOutputBuf) flush(stdout, stderr io.Writer) error {
-	b.mu.Lock()
-
-	var err error
-	b.stdout = stdout
-	b.stderr = stderr
-	for _, e := range b.output {
-		var w io.Writer
-		var errDst *error
-		if e.stderr {
-			w = stderr
-			errDst = &b.errerr
-		} else {
-			w = stdout
-			errDst = &b.outerr
-		}
-		if *errDst != nil {
-			continue
-		}
-
-		_, werr := w.Write(e.data)
-		if werr != nil {
-			if err == nil {
-				err = werr
-			}
-			*errDst = err
-		}
-	}
-
-	b.mu.Unlock()
-
-	<-b.done
-
-	return err
-}
-
-// testStdout writes stdout from a test to the output buffer.
-type testStdout testOutputBuf
-
-func (out *testStdout) Write(data []byte) (int, error) {
-	buf := (*testOutputBuf)(out)
-	buf.mu.Lock()
-
-	if buf.stdout != nil {
-		// Write the output directly.
-		err := out.outerr
-		buf.mu.Unlock()
-		if err != nil {
-			return 0, err
-		}
-		return buf.stdout.Write(data)
-	}
-
-	defer buf.mu.Unlock()
-
-	// Append the output.
-	if len(buf.output) == 0 || buf.output[len(buf.output)-1].stderr {
-		buf.output = append(buf.output, outputEntry{
-			stderr: false,
-		})
-	}
-	last := &buf.output[len(buf.output)-1]
-	last.data = append(last.data, data...)
-
-	return len(data), nil
-}
-
-// testStderr writes stderr from a test to the output buffer.
-type testStderr testOutputBuf
-
-func (out *testStderr) Write(data []byte) (int, error) {
-	buf := (*testOutputBuf)(out)
-	buf.mu.Lock()
-
-	if buf.stderr != nil {
-		// Write the output directly.
-		err := out.errerr
-		buf.mu.Unlock()
-		if err != nil {
-			return 0, err
-		}
-		return buf.stderr.Write(data)
-	}
-
-	defer buf.mu.Unlock()
-
-	// Append the output.
-	if len(buf.output) == 0 || !buf.output[len(buf.output)-1].stderr {
-		buf.output = append(buf.output, outputEntry{
-			stderr: true,
-		})
-	}
-	last := &buf.output[len(buf.output)-1]
-	last.data = append(last.data, data...)
-
-	return len(data), nil
-}
-
-type outputEntry struct {
-	stderr bool
-	data   []byte
-}

main_test.go

@@ -6,16 +6,12 @@ package main
 import (
 	"bufio"
 	"bytes"
-	"context"
-	"errors"
 	"flag"
 	"fmt"
-	"io"
 	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
-	"regexp"
 	"runtime"
 	"strings"
 	"sync"
@@ -31,11 +27,7 @@ const TESTDATA = "testdata"
 
 var testTarget = flag.String("target", "", "override test target")
 
-var sema = make(chan struct{}, runtime.NumCPU())
-
-func TestBuild(t *testing.T) {
-	t.Parallel()
-
+func TestCompiler(t *testing.T) {
 	tests := []string{
 		"alias.go",
 		"atomic.go",
@@ -62,6 +54,7 @@ func TestBuild(t *testing.T) {
 		"testing.go",
 		"zeroalloc.go",
 	}
+
 	_, minor, err := goenv.GetGorootVersion(goenv.Get("GOROOT"))
 	if err != nil {
 		t.Fatal("could not read version from GOROOT:", err)
@@ -74,15 +67,48 @@ func TestBuild(t *testing.T) {
 		// This makes it possible to run one specific test (instead of all),
 		// which is especially useful to quickly check whether some changes
 		// affect a particular target architecture.
-		runPlatTests(optionsFromTarget(*testTarget, sema), tests, t)
+		runPlatTests(optionsFromTarget(*testTarget), tests, t)
 		return
 	}
 
 	t.Run("Host", func(t *testing.T) {
-		t.Parallel()
-		runPlatTests(optionsFromTarget("", sema), tests, t)
+		runPlatTests(optionsFromTarget(""), tests, t)
 	})
 
+	if testing.Short() {
+		return
+	}
+
+	t.Run("EmulatedCortexM3", func(t *testing.T) {
+		runPlatTests(optionsFromTarget("cortex-m-qemu"), tests, t)
+	})
+
+	if runtime.GOOS == "windows" || runtime.GOOS == "darwin" {
+		// Note: running only on Windows and macOS because Linux (as of 2020)
+		// usually has an outdated QEMU version that doesn't support RISC-V yet.
+		t.Run("EmulatedRISCV", func(t *testing.T) {
+			runPlatTests(optionsFromTarget("riscv-qemu"), tests, t)
+		})
+	}
+
+	if runtime.GOOS == "linux" {
+		t.Run("X86Linux", func(t *testing.T) {
+			runPlatTests(optionsFromOSARCH("linux/386"), tests, t)
+		})
+		t.Run("ARMLinux", func(t *testing.T) {
+			runPlatTests(optionsFromOSARCH("linux/arm/6"), tests, t)
+		})
+		t.Run("ARM64Linux", func(t *testing.T) {
+			runPlatTests(optionsFromOSARCH("linux/arm64"), tests, t)
+		})
+		t.Run("WebAssembly", func(t *testing.T) {
+			runPlatTests(optionsFromTarget("wasm"), tests, t)
+		})
+		t.Run("WASI", func(t *testing.T) {
+			runPlatTests(optionsFromTarget("wasi"), tests, t)
+		})
+	}
+
 	// Test a few build options.
 	t.Run("build-options", func(t *testing.T) {
 		t.Parallel()
@@ -90,126 +116,44 @@ func TestBuild(t *testing.T) {
 		// Test with few optimizations enabled (no inlining, etc).
 		t.Run("opt=1", func(t *testing.T) {
 			t.Parallel()
-			opts := optionsFromTarget("", sema)
-			opts.Opt = "1"
-			runTestWithConfig("stdlib.go", t, opts, nil, nil)
+			runTestWithConfig("stdlib.go", t, compileopts.Options{
+				GOOS:   goenv.Get("GOOS"),
+				GOARCH: goenv.Get("GOARCH"),
+				GOARM:  goenv.Get("GOARM"),
+				Opt:    "1",
+			}, nil, nil)
 		})
 
 		// Test with only the bare minimum of optimizations enabled.
 		// TODO: fix this for stdlib.go, which currently fails.
 		t.Run("opt=0", func(t *testing.T) {
 			t.Parallel()
-			opts := optionsFromTarget("", sema)
-			opts.Opt = "0"
-			runTestWithConfig("print.go", t, opts, nil, nil)
+			runTestWithConfig("print.go", t, compileopts.Options{
+				GOOS:   goenv.Get("GOOS"),
+				GOARCH: goenv.Get("GOARCH"),
+				GOARM:  goenv.Get("GOARM"),
+				Opt:    "0",
+			}, nil, nil)
 		})
 
 		t.Run("ldflags", func(t *testing.T) {
 			t.Parallel()
-			opts := optionsFromTarget("", sema)
-			opts.GlobalValues = map[string]map[string]string{
-				"main": {
-					"someGlobal": "foobar",
+			runTestWithConfig("ldflags.go", t, compileopts.Options{
+				GOOS:   goenv.Get("GOOS"),
+				GOARCH: goenv.Get("GOARCH"),
+				GOARM:  goenv.Get("GOARM"),
+				GlobalValues: map[string]map[string]string{
+					"main": {
+						"someGlobal": "foobar",
+					},
 				},
-			}
-			runTestWithConfig("ldflags.go", t, opts, nil, nil)
+			}, nil, nil)
 		})
 	})
-
-	if testing.Short() {
-		// Don't test other targets when the -short flag is used. Only test the
-		// host system.
-		return
-	}
-
-	t.Run("EmulatedCortexM3", func(t *testing.T) {
-		t.Parallel()
-		runPlatTests(optionsFromTarget("cortex-m-qemu", sema), tests, t)
-	})
-
-	t.Run("EmulatedRISCV", func(t *testing.T) {
-		t.Parallel()
-		runPlatTests(optionsFromTarget("riscv-qemu", sema), tests, t)
-	})
-
-	t.Run("AVR", func(t *testing.T) {
-		// LLVM backend crash:
-		// LIBCLANG FATAL ERROR: Cannot select: t3: i16 = JumpTable<0>
-		// This bug is non-deterministic.
-		t.Skip("skipped due to non-deterministic backend bugs")
-
-		var avrTests []string
-		for _, t := range tests {
-			switch t {
-			case "atomic.go":
-				// Requires GCC 11.2.0 or above for interface comparison.
-				// https://github.com/gcc-mirror/gcc/commit/f30dd607669212de135dec1f1d8a93b8954c327c
-
-			case "reflect.go":
-				// Reflect tests do not work due to type code issues.
-
-			case "gc.go":
-				// Does not pass due to high mark false positive rate.
-
-			case "json.go", "stdlib.go", "testing.go":
-				// Breaks interp.
-
-			case "map.go":
-				// Reflect size calculation crashes.
-
-			case "binop.go":
-				// Interface comparison results are inverted.
-
-			case "channel.go":
-				// Freezes after recv from closed channel.
-
-			case "float.go", "math.go", "print.go":
-				// Stuck in runtime.printfloat64.
-
-			case "interface.go":
-				// Several comparison tests fail.
-
-			case "cgo/":
-				// CGo does not work on AVR.
-
-			default:
-				avrTests = append(avrTests, t)
-			}
-		}
-		runPlatTests(optionsFromTarget("simavr", sema), avrTests, t)
-	})
-
-	if runtime.GOOS == "linux" {
-		t.Run("X86Linux", func(t *testing.T) {
-			t.Parallel()
-			runPlatTests(optionsFromOSARCH("linux/386", sema), tests, t)
-		})
-		t.Run("ARMLinux", func(t *testing.T) {
-			t.Parallel()
-			runPlatTests(optionsFromOSARCH("linux/arm/6", sema), tests, t)
-		})
-		t.Run("ARM64Linux", func(t *testing.T) {
-			t.Parallel()
-			runPlatTests(optionsFromOSARCH("linux/arm64", sema), tests, t)
-		})
-		t.Run("WebAssembly", func(t *testing.T) {
-			t.Parallel()
-			runPlatTests(optionsFromTarget("wasm", sema), tests, t)
-		})
-		t.Run("WASI", func(t *testing.T) {
-			t.Parallel()
-			runPlatTests(optionsFromTarget("wasi", sema), tests, t)
-		})
-	}
 }
 
 func runPlatTests(options compileopts.Options, tests []string, t *testing.T) {
-	emuCheck(t, options)
-
-	spec, err := compileopts.LoadTarget(&options)
-	if err != nil {
-		t.Fatal("failed to load target spec:", err)
-	}
+	t.Parallel()
 
 	for _, name := range tests {
 		name := name // redefine to avoid race condition
@@ -218,13 +162,11 @@ func runPlatTests(options compileopts.Options, tests []string, t *testing.T) {
 			runTest(name, options, t, nil, nil)
 		})
 	}
-	if len(spec.Emulator) == 0 || spec.Emulator[0] != "simavr" {
-		t.Run("env.go", func(t *testing.T) {
-			t.Parallel()
-			runTest("env.go", options, t, []string{"first", "second"}, []string{"ENV1=VALUE1", "ENV2=VALUE2"})
-		})
-	}
-	if options.Target == "wasi" || options.Target == "wasm" {
+	t.Run("env.go", func(t *testing.T) {
+		t.Parallel()
+		runTest("env.go", options, t, []string{"first", "second"}, []string{"ENV1=VALUE1", "ENV2=VALUE2"})
+	})
+	if options.Target == "wasi" {
 		t.Run("alias.go-scheduler-none", func(t *testing.T) {
 			t.Parallel()
 			options := compileopts.Options(options)
@@ -246,51 +188,36 @@ func runPlatTests(options compileopts.Options, tests []string, t *testing.T) {
 	}
 }
 
-func emuCheck(t *testing.T, options compileopts.Options) {
-	// Check if the emulator is installed.
-	spec, err := compileopts.LoadTarget(&options)
-	if err != nil {
-		t.Fatal("failed to load target spec:", err)
-	}
-	if len(spec.Emulator) != 0 {
-		_, err := exec.LookPath(spec.Emulator[0])
-		if err != nil {
-			if errors.Is(err, exec.ErrNotFound) {
-				t.Skipf("emulator not installed: %q", spec.Emulator[0])
-			}
+// Due to some problems with LLD, we cannot run links in parallel, or in parallel with compiles.
+// Therefore, we put a lock around builds and run everything else in parallel.
+var buildLock sync.Mutex
 
-			t.Errorf("searching for emulator: %v", err)
-			return
-		}
-	}
+// runBuild is a thread-safe wrapper around Build.
+func runBuild(src, out string, opts *compileopts.Options) error {
+	buildLock.Lock()
+	defer buildLock.Unlock()
+
+	return Build(src, out, opts)
 }
 
-func optionsFromTarget(target string, sema chan struct{}) compileopts.Options {
+func optionsFromTarget(target string) compileopts.Options {
 	return compileopts.Options{
 		// GOOS/GOARCH are only used if target == ""
-		GOOS:      goenv.Get("GOOS"),
-		GOARCH:    goenv.Get("GOARCH"),
-		GOARM:     goenv.Get("GOARM"),
-		Target:    target,
-		Semaphore: sema,
-		Debug:     true,
-		VerifyIR:  true,
-		Opt:       "z",
+		GOOS:   goenv.Get("GOOS"),
+		GOARCH: goenv.Get("GOARCH"),
+		GOARM:  goenv.Get("GOARM"),
+		Target: target,
 	}
 }
 
 // optionsFromOSARCH returns a set of options based on the "osarch" string. This
 // string is in the form of "os/arch/subarch", with the subarch only sometimes
 // being necessary. Examples are "darwin/amd64" or "linux/arm/7".
-func optionsFromOSARCH(osarch string, sema chan struct{}) compileopts.Options {
+func optionsFromOSARCH(osarch string) compileopts.Options {
 	parts := strings.Split(osarch, "/")
 	options := compileopts.Options{
-		GOOS:      parts[0],
-		GOARCH:    parts[1],
-		Semaphore: sema,
-		Debug:     true,
-		VerifyIR:  true,
-		Opt:       "z",
+		GOOS:   parts[0],
+		GOARCH: parts[1],
 	}
 	if options.GOARCH == "arm" {
 		options.GOARM = parts[2]
@@ -303,6 +230,13 @@ func runTest(name string, options compileopts.Options, t *testing.T, cmdArgs, en
 }
 
 func runTestWithConfig(name string, t *testing.T, options compileopts.Options, cmdArgs, environmentVars []string) {
+	// Set default config.
+	options.Debug = true
+	options.VerifyIR = true
+	if options.Opt == "" {
+		options.Opt = "z"
+	}
+
 	// Get the expected output for this test.
 	// Note: not using filepath.Join as it strips the path separator at the end
 	// of the path.
@@ -361,35 +295,22 @@ func runTestWithConfig(name string, t *testing.T, options compileopts.Options, c
 	if spec.GOOS == "windows" {
 		binary += ".exe"
 	}
-	err = Build("./"+path, binary, &options)
+	err = runBuild("./"+path, binary, &options)
 	if err != nil {
 		printCompilerError(t.Log, err)
 		t.Fail()
 		return
 	}
 
-	// Reserve CPU time for the test to run.
-	// This attempts to ensure that the test is not CPU-starved.
-	options.Semaphore <- struct{}{}
-	defer func() { <-options.Semaphore }()
-
 	// Create the test command, taking care of emulators etc.
-	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
-	defer cancel()
 	var cmd *exec.Cmd
-
-	// make sure any special vars in the emulator definition are rewritten
-	config := compileopts.Config{Target: spec}
-	emulator := config.Emulator()
-
-	if len(emulator) == 0 {
-		cmd = exec.CommandContext(ctx, binary)
+	if len(spec.Emulator) == 0 {
+		cmd = exec.Command(binary)
 	} else {
-		args := append(emulator[1:], binary)
-		cmd = exec.CommandContext(ctx, emulator[0], args...)
+		args := append(spec.Emulator[1:], binary)
+		cmd = exec.Command(spec.Emulator[0], args...)
 	}
-
-	if len(emulator) != 0 && emulator[0] == "wasmtime" {
+	if len(spec.Emulator) != 0 && spec.Emulator[0] == "wasmtime" {
 		// Allow reading from the current directory.
 		cmd.Args = append(cmd.Args, "--dir=.")
 		for _, v := range environmentVars {
@@ -404,41 +325,47 @@ func runTestWithConfig(name string, t *testing.T, options compileopts.Options, c
 	}
 
 	// Run the test.
+	runComplete := make(chan struct{})
+	ranTooLong := false
 	stdout := &bytes.Buffer{}
-	if len(emulator) != 0 && emulator[0] == "simavr" {
-		cmd.Stdout = os.Stderr
-		cmd.Stderr = stdout
-	} else {
-		cmd.Stdout = stdout
-		cmd.Stderr = os.Stderr
-	}
+	cmd.Stdout = stdout
+	cmd.Stderr = os.Stderr
 	err = cmd.Start()
 	if err != nil {
 		t.Fatal("failed to start:", err)
 	}
+	go func() {
+		// Terminate the process if it runs too long.
+		maxDuration := 10 * time.Second
+		if runtime.GOOS == "windows" {
+			// For some reason, tests on Windows can take around
+			// 30s to complete. TODO: investigate why and fix this.
+			maxDuration = 40 * time.Second
+		}
+		timer := time.NewTimer(maxDuration)
+		select {
+		case <-runComplete:
+			timer.Stop()
+		case <-timer.C:
+			ranTooLong = true
+			if runtime.GOOS == "windows" {
+				cmd.Process.Signal(os.Kill) // Windows doesn't support SIGINT.
+			} else {
+				cmd.Process.Signal(os.Interrupt)
+			}
+		}
+	}()
 	err = cmd.Wait()
+	close(runComplete)
 
-	if cerr := ctx.Err(); cerr == context.DeadlineExceeded {
+	if ranTooLong {
 		stdout.WriteString("--- test ran too long, terminating...\n")
-		err = cerr
 	}
 
 	// putchar() prints CRLF, convert it to LF.
 	actual := bytes.Replace(stdout.Bytes(), []byte{'\r', '\n'}, []byte{'\n'}, -1)
 	expected = bytes.Replace(expected, []byte{'\r', '\n'}, []byte{'\n'}, -1) // for Windows
 
-	if len(emulator) != 0 && emulator[0] == "simavr" {
-		// Strip simavr log formatting.
-		actual = bytes.Replace(actual, []byte{0x1b, '[', '3', '2', 'm'}, nil, -1)
-		actual = bytes.Replace(actual, []byte{0x1b, '[', '0', 'm'}, nil, -1)
-		actual = bytes.Replace(actual, []byte{'.', '.', '\n'}, []byte{'\n'}, -1)
-	}
-	if name == "testing.go" {
-		// Strip actual time.
-		re := regexp.MustCompile(`\([0-9]\.[0-9][0-9]s\)`)
-		actual = re.ReplaceAllLiteral(actual, []byte{'(', '0', '.', '0', '0', 's', ')'})
-	}
-
 	// Check whether the command ran successfully.
 	fail := false
 	if err != nil {
@@ -462,156 +389,6 @@ func runTestWithConfig(name string, t *testing.T, options compileopts.Options, c
 	}
 }
 
-func TestTest(t *testing.T) {
-	t.Parallel()
-
-	type targ struct {
-		name string
-		opts compileopts.Options
-	}
-	targs := []targ{
-		// Host
-		{"Host", optionsFromTarget("", sema)},
-	}
-	if !testing.Short() {
-		if runtime.GOOS == "linux" {
-			targs = append(targs,
-				// Linux
-				targ{"X86Linux", optionsFromOSARCH("linux/386", sema)},
-				targ{"ARMLinux", optionsFromOSARCH("linux/arm/6", sema)},
-				targ{"ARM64Linux", optionsFromOSARCH("linux/arm64", sema)},
-			)
-		}
-
-		targs = append(targs,
-			// QEMU microcontrollers
-			targ{"EmulatedCortexM3", optionsFromTarget("cortex-m-qemu", sema)},
-			targ{"EmulatedRISCV", optionsFromTarget("riscv-qemu", sema)},
-
-			// Node/Wasmtime
-			targ{"WASM", optionsFromTarget("wasm", sema)},
-			targ{"WASI", optionsFromTarget("wasi", sema)},
-		)
-	}
-	for _, targ := range targs {
-		targ := targ
-		t.Run(targ.name, func(t *testing.T) {
-			t.Parallel()
-
-			emuCheck(t, targ.opts)
-
-			t.Run("Pass", func(t *testing.T) {
-				t.Parallel()
-
-				// Test a package which builds and passes normally.
-
-				var wg sync.WaitGroup
-				defer wg.Wait()
-
-				out := ioLogger(t, &wg)
-				defer out.Close()
-
-				opts := targ.opts
-				passed, err := Test("github.com/tinygo-org/tinygo/tests/testing/pass", out, out, &opts, false, false, false, "", "", "", "")
-				if err != nil {
-					t.Errorf("test error: %v", err)
-				}
-				if !passed {
-					t.Error("test failed")
-				}
-			})
-
-			t.Run("Fail", func(t *testing.T) {
-				t.Parallel()
-
-				// Test a package which builds fine but fails.
-
-				var wg sync.WaitGroup
-				defer wg.Wait()
-
-				out := ioLogger(t, &wg)
-				defer out.Close()
-
-				opts := targ.opts
-				passed, err := Test("github.com/tinygo-org/tinygo/tests/testing/fail", out, out, &opts, false, false, false, "", "", "", "")
-				if err != nil {
-					t.Errorf("test error: %v", err)
-				}
-				if passed {
-					t.Error("test passed")
-				}
-			})
-
-			if targ.name != "Host" {
-				// Emulated tests are somewhat slow, and these do not need to be run across every platform.
-				return
-			}
-
-			t.Run("Nothing", func(t *testing.T) {
-				t.Parallel()
-
-				// Test a package with no test files.
-
-				var wg sync.WaitGroup
-				defer wg.Wait()
-
-				out := ioLogger(t, &wg)
-				defer out.Close()
-
-				var output bytes.Buffer
-				opts := targ.opts
-				passed, err := Test("github.com/tinygo-org/tinygo/tests/testing/nothing", io.MultiWriter(&output, out), out, &opts, false, false, false, "", "", "", "")
-				if err != nil {
-					t.Errorf("test error: %v", err)
-				}
-				if !passed {
-					t.Error("test failed")
-				}
-				if !strings.Contains(output.String(), "[no test files]") {
-					t.Error("missing [no test files] in output")
-				}
-			})
-
-			t.Run("BuildErr", func(t *testing.T) {
-				t.Parallel()
-
-				// Test a package which fails to build.
-
-				var wg sync.WaitGroup
-				defer wg.Wait()
-
-				out := ioLogger(t, &wg)
-				defer out.Close()
-
-				opts := targ.opts
-				passed, err := Test("github.com/tinygo-org/tinygo/tests/testing/builderr", out, out, &opts, false, false, false, "", "", "", "")
-				if err == nil {
-					t.Error("test did not error")
-				}
-				if passed {
-					t.Error("test passed")
-				}
-			})
-		})
-	}
-}
-
-func ioLogger(t *testing.T, wg *sync.WaitGroup) io.WriteCloser {
-	r, w := io.Pipe()
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		defer r.Close()
-
-		scanner := bufio.NewScanner(r)
-		for scanner.Scan() {
-			t.Log(scanner.Text())
-		}
-	}()
-
-	return w
-}
-
 // 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.

src/crypto/rand/rand.go

@@ -15,9 +15,5 @@ var Reader io.Reader
 // Read is a helper function that calls Reader.Read using io.ReadFull.
 // On return, n == len(b) if and only if err == nil.
 func Read(b []byte) (n int, err error) {
-	if Reader == nil {
-		panic("no rng")
-	}
-
 	return io.ReadFull(Reader, b)
 }

src/crypto/rand/rand_arc4random.go

@@ -1,4 +1,4 @@
-// +build darwin tinygo.wasm
+// +build darwin freebsd tinygo.wasm
 
 // This implementation of crypto/rand uses the arc4random_buf function
 // (available on both MacOS and WASI) to generate random numbers.

src/crypto/rand/rand_baremetal.go

@@ -1,36 +0,0 @@
-//go:build stm32 || (sam && atsamd51) || (sam && atsame5x)
-// +build stm32 sam,atsamd51 sam,atsame5x
-
-package rand
-
-import (
-	"machine"
-)
-
-func init() {
-	Reader = &reader{}
-}
-
-type reader struct {
-}
-
-func (r *reader) Read(b []byte) (n int, err error) {
-	if len(b) == 0 {
-		return
-	}
-
-	var randomByte uint32
-	for i := range b {
-		if i%4 == 0 {
-			randomByte, err = machine.GetRNG()
-			if err != nil {
-				return n, err
-			}
-		} else {
-			randomByte >>= 8
-		}
-		b[i] = byte(randomByte)
-	}
-
-	return len(b), nil
-}

src/device/avr/avr_tiny85.go

@@ -1,16 +0,0 @@
-//go:build avr && attiny85
-// +build avr,attiny85
-
-package avr
-
-// The attiny85 have only TIMSK when other AVR boards have TIMSK0 and TIMSK1, etc.
-// Create an alias of TIMSK, TIMSK_OCIE0A, TIMSK_OCIE0B and TIMSK_TOIE0 so we can use
-// common code to mask interrupts.
-
-var TIMSK0 = TIMSK
-
-const (
-	TIMSK0_OCIE0A = TIMSK_OCIE0A
-	TIMSK0_OCIE0B = TIMSK_OCIE0B
-	TIMSK0_TOIE0  = TIMSK_TOIE0
-)

src/examples/rand/main.go

@@ -1,17 +0,0 @@
-package main
-
-import (
-	"crypto/rand"
-	"encoding/hex"
-	"time"
-)
-
-func main() {
-	var result [32]byte
-	for {
-		rand.Read(result[:])
-		encodedString := hex.EncodeToString(result[:])
-		println(encodedString)
-		time.Sleep(time.Second)
-	}
-}