wasm: improve malloc/free heap tracking

Using a slice requires a lot less in code size than a map. This is visible when compiling a very small "hello world" style program. Before tracking memory in malloc/free: 2873 bytes With tracking using a map: 6551 bytes With a slice instead of a map: 3532 bytes Of course, most of this code size increase won't be visible with https://github.com/tinygo-org/tinygo/pull/3142, but it's still a saving of around 3kB in this minimal example.
tests: do not cast pointers to uintptr
2026-07-26 14:48:40 +00:00 · 2022-09-30 14:28:54 +02:00 · 2022-09-30 14:28:54 +02:00 · 2022-09-15 09:14:39 +02:00 · 2022-09-14 19:52:04 +02:00 · 2022-09-14 15:43:14 +02:00
725 changed files with 23143 additions and 8469 deletions
@@ -22,15 +22,16 @@ commands:
    steps:
      - restore_cache:
          keys:
-            - llvm-source-13-v1
+            - llvm-source-14-v3
      - run:
          name: "Fetch LLVM source"
          command: make llvm-source
      - save_cache:
-          key: llvm-source-13-v1
+          key: llvm-source-14-v3
          paths:
            - llvm-project/clang/lib/Headers
            - llvm-project/clang/include
+            - llvm-project/compiler-rt
            - llvm-project/lld/include
            - llvm-project/llvm/include
  hack-ninja-jobs:
@@ -44,29 +45,32 @@ commands:
    steps:
      - restore_cache:
          keys:
-            - binaryen-linux-v1
+            - binaryen-linux-v2
      - run:
          name: "Build Binaryen"
          command: |
            make binaryen
      - save_cache:
-          key: binaryen-linux-v1
+          key: binaryen-linux-v2
          paths:
            - build/wasm-opt
  test-linux:
    parameters:
      llvm:
        type: string
+      fmt-check:
+        type: boolean
+        default: true
    steps:
      - checkout
      - submodules
      - run:
          name: "Install apt dependencies"
          command: |
-            echo 'deb https://apt.llvm.org/buster/ llvm-toolchain-buster-<<parameters.llvm>> main' | sudo tee /etc/apt/sources.list.d/llvm.list
-            wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
-            sudo apt-get update
-            sudo apt-get install --no-install-recommends \
+            echo 'deb https://apt.llvm.org/buster/ llvm-toolchain-buster-<<parameters.llvm>> main' > /etc/apt/sources.list.d/llvm.list
+            wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | apt-key add -
+            apt-get update
+            apt-get install --no-install-recommends -y \
                llvm-<<parameters.llvm>>-dev \
                clang-<<parameters.llvm>> \
                libclang-<<parameters.llvm>>-dev \
@@ -79,43 +83,55 @@ commands:
      - build-binaryen-linux
      - restore_cache:
          keys:
-            - go-cache-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_PREVIOUS_BUILD_NUM }}
-            - go-cache-v2-{{ checksum "go.mod" }}
+            - go-cache-v3-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_PREVIOUS_BUILD_NUM }}
+            - go-cache-v3-{{ checksum "go.mod" }}
      - llvm-source-linux
      - run: go install -tags=llvm<<parameters.llvm>> .
      - restore_cache:
          keys:
-            - wasi-libc-sysroot-systemclang-v3
+            - wasi-libc-sysroot-systemclang-v6
      - run: make wasi-libc
      - save_cache:
-          key: wasi-libc-sysroot-systemclang-v3
+          key: wasi-libc-sysroot-systemclang-v6
          paths:
            - lib/wasi-libc/sysroot
+      - when:
+          condition: <<parameters.fmt-check>>
+          steps:
+          - run:
+              # Do this before gen-device so that it doesn't check the
+              # formatting of generated files.
+              name: Check Go code formatting
+              command: make fmt-check
      - run: make gen-device -j4
      - run: make smoketest XTENSA=0
      - save_cache:
-          key: go-cache-v2-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_BUILD_NUM }}
+          key: go-cache-v3-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_BUILD_NUM }}
          paths:
            - ~/.cache/go-build
            - /go/pkg/mod
-      - run: make fmt-check

 jobs:
-  test-llvm11-go115:
+  test-llvm14-go118:
    docker:
-      - image: circleci/golang:1.15-buster
+      - image: golang:1.18-buster
    steps:
      - test-linux:
-          llvm: "11"
-  test-llvm12-go116:
+          llvm: "14"
+  test-llvm14-go119:
    docker:
-      - image: circleci/golang:1.16-buster
+      - image: golang:1.19beta1-buster
    steps:
      - test-linux:
-          llvm: "12"
+          llvm: "14"
+          fmt-check: false

 workflows:
  test-all:
    jobs:
-      - test-llvm11-go115
-      - test-llvm12-go116
+      # This tests our lowest supported versions of Go and LLVM, to make sure at
+      # least the smoke tests still pass.
+      - test-llvm14-go118
+      # This tests a beta version of Go. It should be removed once regular
+      # release builds are built using this version.
+      - test-llvm14-go119
@@ -7,15 +7,15 @@ on:
      - dev
      - release

+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
  build-macos:
    name: build-macos
-    runs-on: macos-10.15
+    runs-on: macos-11
    steps:
-      - name: Install Go
-        uses: actions/setup-go@v2
-        with:
-          go-version: '1.17'
      - name: Install Dependencies
        shell: bash
        run: |
@@ -31,24 +31,30 @@ jobs:
        uses: actions/checkout@v2
        with:
          submodules: true
+      - name: Install Go
+        uses: actions/setup-go@v3
+        with:
+          go-version: '1.18.1'
+          cache: true
      - name: Cache LLVM source
-        uses: actions/cache@v2
+        uses: actions/cache@v3
        id: cache-llvm-source
        with:
-          key: llvm-source-13-macos-v1
+          key: llvm-source-14-macos-v1
          path: |
            llvm-project/clang/lib/Headers
            llvm-project/clang/include
+            llvm-project/compiler-rt
            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
+        uses: actions/cache@v3
        id: cache-llvm-build
        with:
-          key: llvm-build-13-macos-v2
+          key: llvm-build-14-macos-v1
          path: llvm-build
      - name: Build LLVM
        if: steps.cache-llvm-build.outputs.cache-hit != 'true'
@@ -63,10 +69,10 @@ jobs:
          make llvm-build
          find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
      - name: Cache wasi-libc sysroot
-        uses: actions/cache@v2
+        uses: actions/cache@v3
        id: cache-wasi-libc
        with:
-          key: wasi-libc-sysroot-v1
+          key: wasi-libc-sysroot-v4
          path: lib/wasi-libc/sysroot
      - name: Build wasi-libc
        if: steps.cache-wasi-libc.outputs.cache-hit != 'true'
@@ -76,6 +82,8 @@ jobs:
        run: make test GOTESTFLAGS="-v -short"
      - name: Build TinyGo release tarball
        run: make release -j3
+      - name: Test stdlib packages
+        run: make tinygo-test
      - name: Make release artifact
        shell: bash
        run: cp -p build/release.tar.gz build/tinygo.darwin-amd64.tar.gz 
@@ -93,3 +101,22 @@ jobs:
      - name: Smoke tests
        shell: bash
        run: make smoketest TINYGO=$(PWD)/build/tinygo AVR=0
+  test-macos-homebrew:
+    name: homebrew-install
+    runs-on: macos-latest
+    steps:
+      - name: Install LLVM
+        shell: bash
+        run: |
+          HOMEBREW_NO_AUTO_UPDATE=1 brew install llvm@14
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Install Go
+        uses: actions/setup-go@v3
+        with:
+          go-version: '1.18'
+          cache: true
+      - name: Build TinyGo
+        run: go install
+      - name: Check binary
+        run: tinygo version
@@ -7,6 +7,10 @@ on:
  push:
    branches: [ dev, fix-docker-llvm-build ]

+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
  push_to_registry:
    name: build-push-dev
@@ -51,9 +55,35 @@ jobs:
          labels: ${{ steps.meta.outputs.labels }}
          cache-from: type=gha
          cache-to: type=gha,mode=max
-      - name: Trigger Drivers repo build on CircleCI
+      - name: Trigger Drivers repo build on Github Actions
        run: |
-          curl --location --request POST 'https://circleci.com/api/v2/project/github/tinygo-org/drivers/pipeline' \
+          curl -X POST \
+          -H "Authorization: Bearer ${{secrets.GHA_ACCESS_TOKEN}}" \
+          -H "Accept: application/vnd.github.v3+json" \
+          https://api.github.com/repos/tinygo-org/drivers/actions/workflows/build.yml/dispatches \
+          -d '{"ref": "dev"}'
+      - name: Trigger Bluetooth repo build on Github Actions
+        run: |
+          curl -X POST \
+          -H "Authorization: Bearer ${{secrets.GHA_ACCESS_TOKEN}}" \
+          -H "Accept: application/vnd.github.v3+json" \
+          https://api.github.com/repos/tinygo-org/bluetooth/actions/workflows/linux.yml/dispatches \
+          -d '{"ref": "dev"}'
+      - name: Trigger TinyFS repo build on CircleCI
+        run: |
+          curl --location --request POST 'https://circleci.com/api/v2/project/github/tinygo-org/tinyfs/pipeline' \
+            --header 'Content-Type: application/json' \
+            -d '{"branch": "dev"}' \
+            -u "${{ secrets.CIRCLECI_API_TOKEN }}"
+      - name: Trigger TinyFont repo build on CircleCI
+        run: |
+          curl --location --request POST 'https://circleci.com/api/v2/project/github/tinygo-org/tinyfont/pipeline' \
+            --header 'Content-Type: application/json' \
+            -d '{"branch": "dev"}' \
+            -u "${{ secrets.CIRCLECI_API_TOKEN }}"
+      - name: Trigger TinyDraw repo build on CircleCI
+        run: |
+          curl --location --request POST 'https://circleci.com/api/v2/project/github/tinygo-org/tinydraw/pipeline' \
            --header 'Content-Type: application/json' \
            -d '{"branch": "dev"}' \
            -u "${{ secrets.CIRCLECI_API_TOKEN }}"
@@ -7,51 +7,57 @@ on:
      - dev
      - release

+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 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
+    # This runs inside an Alpine Linux container so we can more easily create a
+    # statically linked binary.
+    runs-on: ubuntu-latest
+    container:
+      image: golang:1.18-alpine
    steps:
+      - name: Install apk dependencies
+        # tar: needed for actions/cache@v3
+        # git+openssh: needed for checkout (I think?)
+        # ruby: needed to install fpm
+        run: apk add tar git openssh make g++ ruby
+      - name: Work around CVE-2022-24765
+        # We're not on a multi-user machine, so this is safe.
+        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
      - 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
+        uses: actions/cache@v3
        with:
-          key: go-cache-linux-v1-${{ hashFiles('go.mod') }}
+          key: go-cache-linux-alpine-v1-${{ hashFiles('go.mod') }}
          path: |
            ~/.cache/go-build
            ~/go/pkg/mod
      - name: Cache LLVM source
-        uses: actions/cache@v2
+        uses: actions/cache@v3
        id: cache-llvm-source
        with:
-          key: llvm-source-13-linux-v1
+          key: llvm-source-14-linux-alpine-v1
          path: |
            llvm-project/clang/lib/Headers
            llvm-project/clang/include
+            llvm-project/compiler-rt
            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
+        uses: actions/cache@v3
        id: cache-llvm-build
        with:
-          key: llvm-build-13-linux-v1
+          key: llvm-build-14-linux-alpine-v1
          path: llvm-build
      - name: Build LLVM
        if: steps.cache-llvm-build.outputs.cache-hit != 'true'
@@ -59,41 +65,46 @@ jobs:
          # fetch LLVM source
          rm -rf llvm-project
          make llvm-source
+          # install dependencies
+          apk add cmake samurai python3
          # 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
+        uses: actions/cache@v3
        id: cache-binaryen
        with:
-          key: binaryen-linux-v1
+          key: binaryen-linux-alpine-v1
          path: build/wasm-opt
      - name: Build Binaryen
        if: steps.cache-binaryen.outputs.cache-hit != 'true'
-        run: make binaryen
+        run: |
+          apk add cmake samurai python3
+          make binaryen STATIC=1
      - name: Cache wasi-libc
-        uses: actions/cache@v2
+        uses: actions/cache@v3
        id: cache-wasi-libc
        with:
-          key: wasi-libc-sysroot-linux-asserts-v2
+          key: wasi-libc-sysroot-linux-alpine-v1
          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
+          gem install --version 4.0.7 public_suffix
+          gem install --version 2.7.6 dotenv
+          gem install --no-document fpm
      - name: Build TinyGo release
        run: |
-          make release deb -j3
+          make release deb -j3 STATIC=1
          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
+          name: linux-amd64-double-zipped
          path: |
            /tmp/tinygo.linux-amd64.tar.gz
            /tmp/tinygo_amd64.deb
@@ -105,9 +116,10 @@ jobs:
      - name: Checkout
        uses: actions/checkout@v2
      - name: Install Go
-        uses: actions/setup-go@v2
+        uses: actions/setup-go@v3
        with:
-          go-version: '1.17'
+          go-version: '1.18.1'
+          cache: true
      - name: Install wasmtime
        run: |
          curl https://wasmtime.dev/install.sh -sSf | bash
@@ -115,7 +127,7 @@ jobs:
      - name: Download release artifact
        uses: actions/download-artifact@v2
        with:
-          name: release-double-zipped
+          name: linux-amd64-double-zipped
      - name: Extract release tarball
        run: |
          mkdir -p ~/lib
@@ -157,42 +169,37 @@ jobs:
              simavr \
              ninja-build
      - name: Install Go
-        uses: actions/setup-go@v2
+        uses: actions/setup-go@v3
        with:
-          go-version: '1.17'
+          go-version: '1.18.1'
+          cache: true
      - name: Install Node.js
        uses: actions/setup-node@v2
        with:
-          node-version: '12'
+          node-version: '14'
      - 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
+        uses: actions/cache@v3
        id: cache-llvm-source
        with:
-          key: llvm-source-13-linux-asserts-v1
+          key: llvm-source-14-linux-asserts-v2
          path: |
            llvm-project/clang/lib/Headers
            llvm-project/clang/include
+            llvm-project/compiler-rt
            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
+        uses: actions/cache@v3
        id: cache-llvm-build
        with:
-          key: llvm-build-13-linux-asserts-v1
+          key: llvm-build-14-linux-asserts-v1
          path: llvm-build
      - name: Build LLVM
        if: steps.cache-llvm-build.outputs.cache-hit != 'true'
@@ -205,7 +212,7 @@ jobs:
          # Remove unnecessary object files (to reduce cache size).
          find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
      - name: Cache Binaryen
-        uses: actions/cache@v2
+        uses: actions/cache@v3
        id: cache-binaryen
        with:
          key: binaryen-linux-asserts-v1
@@ -214,10 +221,10 @@ jobs:
        if: steps.cache-binaryen.outputs.cache-hit != 'true'
        run: make binaryen
      - name: Cache wasi-libc
-        uses: actions/cache@v2
+        uses: actions/cache@v3
        id: cache-wasi-libc
        with:
-          key: wasi-libc-sysroot-linux-asserts-v2
+          key: wasi-libc-sysroot-linux-asserts-v5
          path: lib/wasi-libc/sysroot
      - name: Build wasi-libc
        if: steps.cache-wasi-libc.outputs.cache-hit != 'true'
@@ -239,3 +246,203 @@ jobs:
          rm xtensa-esp32-elf-gcc8_2_0-esp-2020r2-linux-amd64.tar.gz
      - run: make smoketest
      - run: make wasmtest
+      - run: make tinygo-baremetal
+  build-linux-arm:
+    # Build ARM 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.
+    # It is set to "needs: build-linux" because it modifies the release created
+    # in that process to avoid doing lots of duplicate work and to avoid
+    # complications around precompiled libraries such as compiler-rt shipped as
+    # part of the release tarball.
+    runs-on: ubuntu-18.04
+    needs: build-linux
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Install apt dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install --no-install-recommends \
+              qemu-user \
+              g++-arm-linux-gnueabihf \
+              libc6-dev-armhf-cross
+      - name: Install Go
+        uses: actions/setup-go@v3
+        with:
+          go-version: '1.18.1'
+          cache: true
+      - name: Cache LLVM source
+        uses: actions/cache@v3
+        id: cache-llvm-source
+        with:
+          key: llvm-source-14-linux-v2
+          path: |
+            llvm-project/clang/lib/Headers
+            llvm-project/clang/include
+            llvm-project/compiler-rt
+            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@v3
+        id: cache-llvm-build
+        with:
+          key: llvm-build-14-linux-arm-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
+          # Install build dependencies.
+          sudo apt-get install --no-install-recommends ninja-build
+          # build!
+          make llvm-build CROSS=arm-linux-gnueabihf
+          # Remove unnecessary object files (to reduce cache size).
+          find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
+      - name: Cache Binaryen
+        uses: actions/cache@v3
+        id: cache-binaryen
+        with:
+          key: binaryen-linux-arm-v1
+          path: build/wasm-opt
+      - name: Build Binaryen
+        if: steps.cache-binaryen.outputs.cache-hit != 'true'
+        run: |
+          sudo apt-get install --no-install-recommends ninja-build
+          git submodule update --init lib/binaryen
+          make CROSS=arm-linux-gnueabihf binaryen
+      - name: Install fpm
+        run: |
+          sudo gem install --version 4.0.7 public_suffix
+          sudo gem install --version 2.7.6 dotenv
+          sudo gem install --no-document fpm
+      - name: Build TinyGo binary
+        run: |
+          make CROSS=arm-linux-gnueabihf
+      - name: Download amd64 release
+        uses: actions/download-artifact@v2
+        with:
+          name: linux-amd64-double-zipped
+      - name: Extract amd64 release
+        run: |
+          mkdir -p build/release
+          tar -xf tinygo.linux-amd64.tar.gz -C build/release tinygo
+      - name: Modify release
+        run: |
+          cp -p build/tinygo   build/release/tinygo/bin
+          cp -p build/wasm-opt build/release/tinygo/bin
+      - name: Create arm release
+        run: |
+          make release deb RELEASEONLY=1 DEB_ARCH=armhf
+          cp -p build/release.tar.gz /tmp/tinygo.linux-arm.tar.gz
+          cp -p build/release.deb    /tmp/tinygo_armhf.deb
+      - name: Publish release artifact
+        uses: actions/upload-artifact@v2
+        with:
+          name: linux-arm-double-zipped
+          path: |
+            /tmp/tinygo.linux-arm.tar.gz
+            /tmp/tinygo_armhf.deb
+  build-linux-arm64:
+    # Build ARM64 Linux binaries, ready for release.
+    # It is set to "needs: build-linux" because it modifies the release created
+    # in that process to avoid doing lots of duplicate work and to avoid
+    # complications around precompiled libraries such as compiler-rt shipped as
+    # part of the release tarball.
+    runs-on: ubuntu-18.04
+    needs: build-linux
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Install apt dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install --no-install-recommends \
+              qemu-user \
+              g++-aarch64-linux-gnu \
+              libc6-dev-arm64-cross \
+              ninja-build
+      - name: Install Go
+        uses: actions/setup-go@v3
+        with:
+          go-version: '1.18.1'
+          cache: true
+      - name: Cache LLVM source
+        uses: actions/cache@v3
+        id: cache-llvm-source
+        with:
+          key: llvm-source-14-linux-v1
+          path: |
+            llvm-project/clang/lib/Headers
+            llvm-project/clang/include
+            llvm-project/compiler-rt
+            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@v3
+        id: cache-llvm-build
+        with:
+          key: llvm-build-14-linux-arm64-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 CROSS=aarch64-linux-gnu
+          # Remove unnecessary object files (to reduce cache size).
+          find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
+      - name: Cache Binaryen
+        uses: actions/cache@v3
+        id: cache-binaryen
+        with:
+          key: binaryen-linux-arm64-v1
+          path: build/wasm-opt
+      - name: Build Binaryen
+        if: steps.cache-binaryen.outputs.cache-hit != 'true'
+        run: |
+          git submodule update --init lib/binaryen
+          make CROSS=aarch64-linux-gnu binaryen
+      - name: Install fpm
+        run: |
+          sudo gem install --version 4.0.7 public_suffix
+          sudo gem install --version 2.7.6 dotenv
+          sudo gem install --no-document fpm
+      - name: Build TinyGo binary
+        run: |
+          make CROSS=aarch64-linux-gnu
+      - name: Download amd64 release
+        uses: actions/download-artifact@v2
+        with:
+          name: linux-amd64-double-zipped
+      - name: Extract amd64 release
+        run: |
+          mkdir -p build/release
+          tar -xf tinygo.linux-amd64.tar.gz -C build/release tinygo
+      - name: Modify release
+        run: |
+          cp -p build/tinygo   build/release/tinygo/bin
+          cp -p build/wasm-opt build/release/tinygo/bin
+      - name: Create arm64 release
+        run: |
+          make release deb RELEASEONLY=1 DEB_ARCH=arm64
+          cp -p build/release.tar.gz /tmp/tinygo.linux-arm64.tar.gz
+          cp -p build/release.deb    /tmp/tinygo_arm64.deb
+      - name: Publish release artifact
+        uses: actions/upload-artifact@v2
+        with:
+          name: linux-arm64-double-zipped
+          path: |
+            /tmp/tinygo.linux-arm64.tar.gz
+            /tmp/tinygo_arm64.deb
@@ -7,15 +7,17 @@ on:
      - dev
      - release

+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
  build-windows:
-    runs-on: windows-2019
+    runs-on: windows-2022
    steps:
-      - name: Install Go
-        uses: actions/setup-go@v2
+      - uses: brechtm/setup-scoop@v2
        with:
-          go-version: '1.17'
-      - uses: MinoruSekine/setup-scoop@v1
+          scoop_update: 'false'
      - name: Install Dependencies
        shell: bash
        run: |
@@ -24,31 +26,30 @@ jobs:
        uses: actions/checkout@v2
        with:
          submodules: true
-      - name: Cache Go
-        uses: actions/cache@v2
+      - name: Install Go
+        uses: actions/setup-go@v3
        with:
-          key: go-cache-windows-v1-${{ hashFiles('go.mod') }}
-          path: |
-            ~/AppData/Local/go-build
-            ~/go/pkg/mod
+          go-version: '1.18.1'
+          cache: true
      - name: Cache LLVM source
-        uses: actions/cache@v2
+        uses: actions/cache@v3
        id: cache-llvm-source
        with:
-          key: llvm-source-13-windows-v1
+          key: llvm-source-14-windows-v2
          path: |
            llvm-project/clang/lib/Headers
            llvm-project/clang/include
+            llvm-project/compiler-rt
            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
+        uses: actions/cache@v3
        id: cache-llvm-build
        with:
-          key: llvm-build-13-windows-v1
+          key: llvm-build-14-windows-v2
          path: llvm-build
      - name: Build LLVM
        if: steps.cache-llvm-build.outputs.cache-hit != 'true'
@@ -58,22 +59,26 @@ jobs:
          rm -rf llvm-project
          make llvm-source
          # build!
-          make llvm-build
+          make llvm-build CCACHE=OFF
          # Remove unnecessary object files (to reduce cache size).
          find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
      - name: Cache wasi-libc sysroot
-        uses: actions/cache@v2
+        uses: actions/cache@v3
        id: cache-wasi-libc
        with:
-          key: wasi-libc-sysroot-v1
+          key: wasi-libc-sysroot-v4
          path: lib/wasi-libc/sysroot
      - name: Build wasi-libc
        if: steps.cache-wasi-libc.outputs.cache-hit != 'true'
        run: make wasi-libc
+      - name: Install wasmtime
+        run: |
+          scoop install wasmtime
      - name: Test TinyGo
        shell: bash
        run: make test GOTESTFLAGS="-v -short"
      - name: Build TinyGo release tarball
+        shell: bash
        run: make build/release -j4
      - name: Make release artifact
        shell: bash
@@ -95,3 +100,5 @@ jobs:
        run: make smoketest TINYGO=$(PWD)/build/tinygo AVR=0 XTENSA=0
      - name: Test stdlib packages
        run: make tinygo-test
+      - name: Test stdlib packages on wasi
+        run: make tinygo-test-wasi-fast
@@ -23,6 +23,7 @@ llvm-project
 build/*

 # Ignore files generated by smoketest
+test
 test.bin
 test.elf
 test.exe
@@ -30,4 +31,4 @@ test.gba
 test.hex
 test.nro
 test.wasm
-wasm.wasm
+wasm.wasm
@@ -10,10 +10,6 @@
 [submodule "lib/cmsis-svd"]
 	path = lib/cmsis-svd
 	url = https://github.com/tinygo-org/cmsis-svd
-[submodule "lib/compiler-rt"]
-	path = lib/compiler-rt
-	url = https://github.com/llvm-mirror/compiler-rt.git
-	branch = release_80
 [submodule "lib/wasi-libc"]
 	path = lib/wasi-libc
 	url = https://github.com/CraneStation/wasi-libc
@@ -32,3 +28,6 @@
 [submodule "lib/mingw-w64"]
 	path = lib/mingw-w64
 	url = https://github.com/mingw-w64/mingw-w64.git
+[submodule "lib/macos-minimal-sdk"]
+	path = lib/macos-minimal-sdk
+	url = https://github.com/aykevl/macos-minimal-sdk.git
@@ -18,7 +18,7 @@ tarball. If you want to help with development of TinyGo itself, you should follo
 LLVM, Clang and LLD are quite light on dependencies, requiring only standard
 build tools to be built. Go is of course necessary to build TinyGo itself.

-  * Go (1.15+)
+  * Go (1.18+)
  * Standard build tools (gcc/clang)
  * git
  * CMake
@@ -1,3 +1,208 @@
+0.25.0
+---
+
+* **command line**
+  - change to ignore PortReset failures
+* **compiler**
+  - `compiler`: darwin/arm64 is aarch64, not arm
+  - `compiler`: don't clobber X18 and FP registers on darwin/arm64
+  - `compiler`: fix issue with methods on generic structs
+  - `compiler`: do not try to build generic functions
+  - `compiler`: fix type names for generic named structs
+  - `compiler`: fix multiple defined function issue for generic functions
+  - `compiler`: implement `unsafe.Alignof` and `unsafe.Sizeof` for generic code
+* **standard library**
+  - `machine`: add DTR and RTS to Serialer interface
+  - `machine`: reorder pin definitions to improve pin list on tinygo.org
+  - `machine/usb`: add support for MIDI
+  - `machine/usb`: adjust buffer alignment (samd21, samd51, nrf52840)
+  - `machine/usb/midi`: add `NoteOn`, `NoteOff`, and `SendCC` methods
+  - `machine/usb/midi`: add definition of MIDI note number
+  - `runtime`: add benchmarks for memhash
+  - `runtime`: add support for printing slices via print/println
+* **targets**
+  - `avr`: fix some apparent mistake in atmega1280/atmega2560 pin constants
+  - `esp32`: provide hardware pin constants
+  - `esp32`: fix WDT reset on the MCH2022 badge
+  - `esp32`: optimize SPI transmit
+  - `esp32c3`: provide hardware pin constants
+  - `esp8266`: provide hardware pin constants like `GPIO2`
+  - `nrf51`: define and use `P0_xx` constants
+  - `nrf52840`, `samd21`, `samd51`: unify bootloader entry process
+  - `nrf52840`, `samd21`, `samd51`: change usbSetup and sendZlp to public
+  - `nrf52840`, `samd21`, `samd51`: refactor handleStandardSetup and initEndpoint
+  - `nrf52840`, `samd21`, `samd51`: improve usb-device initialization
+  - `nrf52840`, `samd21`, `samd51`: move usbcdc to machine/usb/cdc
+  - `rp2040`: add usb serial vendor/product ID
+  - `rp2040`: add support for usb
+  - `rp2040`: change default for serial to usb
+  - `rp2040`: add support for `machine.EnterBootloader`
+  - `rp2040`: turn off pullup/down when input type is not specified
+  - `rp2040`: make picoprobe default openocd interface
+  - `samd51`: add support for `DAC1`
+  - `samd51`: improve TRNG
+  - `wasm`: stub `runtime.buffered`, `runtime.getchar`
+  - `wasi`: make leveldb runtime hash the default
+* **boards**
+  - add Challenger RP2040 LoRa
+  - add MCH2022 badge
+  - add XIAO RP2040
+  - `clue`: remove pins `D21`..`D28`
+  - `feather-rp2040`, `macropad-rp2040`: fix qspi-flash settings
+  - `xiao-ble`: add support for flash-1200-bps-reset
+  - `gopherbot`, `gopherbot2`: add these aliases to simplify for newer users
+
+
+0.24.0
+---
+
+* **command line**
+  - remove support for go 1.15
+  - remove support for LLVM 11 and LLVM 12
+  - add initial Go 1.19 beta support
+  - `test`: fix package/... syntax
+* **compiler**
+  - add support for the embed package
+  - `builder`: improve error message for "command not found"
+  - `builder`: add support for ThinLTO on MacOS and Windows
+  - `builder`: free LLVM objects after use, to reduce memory leaking
+  - `builder`: improve `-no-debug` error messages
+  - `cgo`: be more strict: CGo now requires every Go file to import the headers it needs
+  - `compiler`: alignof(func) is 1 pointer, not 2
+  - `compiler`: add support for type parameters (aka generics)
+  - `compiler`: implement `recover()` built-in function
+  - `compiler`: support atomic, volatile, and LLVM memcpy-like functions in defer
+  - `compiler`: drop support for macos syscalls via inline assembly
+  - `interp`: do not try to interpret past task.Pause()
+  - `interp`: fix some buggy localValue handling
+  - `interp`: do not unroll loops
+  - `transform`: fix MakeGCStackSlots that caused a possible GC bug on WebAssembly
+* **standard library**
+  - `os`: enable os.Stdin for baremetal target
+  - `reflect`: add `Value.UnsafePointer` method
+  - `runtime`: scan GC globals conservatively on Windows, MacOS, Linux and Nintendo Switch
+  - `runtime`: add per-map hash seeds
+  - `runtime`: handle nil map write panics
+  - `runtime`: add stronger hash functions
+  - `syscall`: implement `Getpagesize`
+* **targets**
+  - `atmega2560`: support UART1-3 + example for uart
+  - `avr`: use compiler-rt for improved float64 support
+  - `avr`: simplify timer-based time
+  - `avr`: fix race condition in stack write
+  - `darwin`: add support for `GOARCH=arm64` (aka Apple Silicon)
+  - `darwin`: support `-size=short` and `-size=full` flag
+  - `rp2040`: replace sleep 'busy loop' with timer alarm
+  - `rp2040`: align api for `PortMaskSet`, `PortMaskClear`
+  - `rp2040`: fix GPIO interrupts
+  - `samd21`, `samd51`, `nrf52840`: add support for USBHID (keyboard / mouse)
+  - `wasm`: update wasi-libc version
+  - `wasm`: use newer WebAssembly features
+* **boards**
+  - add Badger 2040
+  - `matrixportal-m4`: attach USB DP to the correct pin
+  - `teensy40`: add I2C support
+  - `wioterminal`: fix I2C definition
+
+
+0.23.0
+---
+
+* **command line**
+  - add `-work` flag
+  - add Go 1.18 support
+  - add LLVM 14 support
+  - `run`: add support for command-line parameters
+  - `build`: calculate default output path if `-o` is not specified
+  - `build`: add JSON output
+  - `test`: support multiple test binaries with `-c`
+  - `test`: support flags like `-v` on all targets (including emulated firmware)
+* **compiler**
+  - add support for ThinLTO
+  - use compiler-rt from LLVM
+  - `builder`: prefer GNU build ID over Go build ID for caching
+  - `builder`: add support for cross compiling to Darwin
+  - `builder`: support machine outlining pass in stacksize calculation
+  - `builder`: disable asynchronous unwind tables
+  - `compileopts`: fix emulator configuration on non-amd64 Linux architectures
+  - `compiler`: move allocations > 256  bytes to the heap
+  - `compiler`: fix incorrect `unsafe.Alignof` on some 32-bit architectures
+  - `compiler`: accept alias for slice `cap` builtin
+  - `compiler`: allow slices of empty structs
+  - `compiler`: fix difference in aliases in interface methods
+  - `compiler`: make `RawSyscall` an alias for `Syscall`
+  - `compiler`: remove support for memory references in `AsmFull`
+  - `loader`: only add Clang header path for CGo
+  - `transform`: fix poison value in heap-to-stack transform
+* **standard library**
+  - `internal/fuzz`: add this package as a shim
+  - `os`: implement readdir for darwin and linux
+  - `os`: add `DirFS`, which is used by many programs to access readdir.
+  - `os`: isWine: be compatible with older versions of wine, too
+  - `os`: implement `RemoveAll`
+  - `os`: Use a `uintptr` for `NewFile`
+  - `os`: add stubs for `exec.ExitError` and `ProcessState.ExitCode`
+  - `os`: export correct values for `DevNull` for each OS
+  - `os`: improve support for `Signal` by fixing various bugs
+  - `os`: implement `File.Fd` method
+  - `os`: implement `UserHomeDir`
+  - `os`: add `exec.ProcessState` stub
+  - `os`: implement `Pipe` for darwin
+  - `os`: define stub `ErrDeadlineExceeded`
+  - `reflect`: add stubs for more missing methods
+  - `reflect`: rename `reflect.Ptr` to `reflect.Pointer`
+  - `reflect`: add `Value.FieldByIndexErr` stub
+  - `runtime`: fix various small GC bugs
+  - `runtime`: use memzero for leaking collector instead of manually zeroing objects
+  - `runtime`: implement `memhash`
+  - `runtime`: implement `fastrand`
+  - `runtime`: add stub for `debug.ReadBuildInfo`
+  - `runtime`: add stub for `NumCPU`
+  - `runtime`: don't inline `runtime.alloc` with `-gc=leaking`
+  - `runtime`: add `Version`
+  - `runtime`: add stubs for `NumCgoCall` and `NumGoroutine`
+  - `runtime`: stub {Lock,Unlock}OSThread on Windows
+  - `runtime`: be able to deal with a very small heap
+  - `syscall`: make `Environ` return a copy of the environment
+  - `syscall`: implement getpagesize and munmap
+  - `syscall`: `wasi`: define `MAP_SHARED` and `PROT_READ`
+  - `syscall`: stub mmap(), munmap(), MAP_SHARED, PROT_READ, SIGBUS, etc. on nonhosted targets
+  - `syscall`: darwin: more complete list of signals
+  - `syscall`: `wasi`: more complete list of signals
+  - `syscall`: stub `WaitStatus`
+  - `syscall/js`: allow copyBytesTo(Go|JS) to use `Uint8ClampedArray`
+  - `testing`: implement `TempDir`
+  - `testing`: nudge type TB closer to upstream; should be a no-op change.
+  - `testing`: on baremetal platforms, use simpler test matcher
+* **targets**
+  - `atsamd`: fix usbcdc initialization when `-serial=uart`
+  - `atsamd51`: allow higher frequency when using SPI
+  - `esp`: support CGo
+  - `esp32c3`: add support for input pin
+  - `esp32c3`: add support for GPIO interrupts
+  - `esp32c3`: add support to receive UART data
+  - `rp2040`: fix PWM bug at high frequency
+  - `rp2040`: fix some minor I2C bugs
+  - `rp2040`: fix incorrect inline assembly
+  - `rp2040`: fix spurious i2c STOP during write+read transaction
+  - `rp2040`: improve ADC support
+  - `wasi`: remove `--export-dynamic` linker flag
+  - `wasm`: remove heap allocator from wasi-libc
+* **boards**
+  - `circuitplay-bluefruit`: move pin mappings so board can be compiled for WASM use in Playground
+  - `esp32-c3-12f`: add the ESP32-C3-12f Kit
+  - `m5stamp-c3`: add pin setting of UART
+  - `macropad-rp2040`: add the Adafruit MacroPad RP2040 board
+  - `nano-33-ble`: typo in LPS22HB peripheral definition and documentation (#2579)
+  - `teensy41`: add the Teensy 4.1 board
+  - `teensy40`: add ADC support
+  - `teensy40`: add SPI support
+  - `thingplus-rp2040`: add the SparkFun Thing Plus RP2040 board
+  - `wioterminal`: add DefaultUART
+  - `wioterminal`: verify written data when flashing through OpenOCD
+  - `xiao-ble`: add XIAO BLE nRF52840 support
+
+
 0.22.0
 ---

@@ -1,5 +1,5 @@
 # tinygo-llvm stage obtains the llvm source for TinyGo
-FROM golang:1.17 AS tinygo-llvm
+FROM golang:1.18 AS tinygo-llvm

 RUN apt-get update && \
    apt-get install -y apt-utils make cmake clang-11 binutils-avr gcc-avr avr-libc ninja-build
@@ -10,7 +10,7 @@ LLD_SRC ?= $(LLVM_PROJECTDIR)/lld

 # Try to autodetect LLVM build tools.
 # Versions are listed here in descending priority order.
-LLVM_VERSIONS = 13 12 11
+LLVM_VERSIONS = 14 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)
@@ -38,10 +38,16 @@ MD5SUM = md5sum
 # tinygo binary for tests
 TINYGO ?= $(call detect,tinygo,tinygo $(CURDIR)/build/tinygo)

-# Use CCACHE for LLVM if possible
-ifneq (, $(shell command -v ccache 2> /dev/null))
-    LLVM_OPTION += '-DLLVM_CCACHE_BUILD=ON'
+# Check for ccache if the user hasn't set it to on or off.
+ifeq (, $(CCACHE))
+    # Use CCACHE for LLVM if possible
+    ifneq (, $(shell command -v ccache 2> /dev/null))
+        CCACHE := ON
+    else
+        CCACHE := OFF
+    endif
 endif
+LLVM_OPTION += '-DLLVM_CCACHE_BUILD=$(CCACHE)'

 # Allow enabling LLVM assertions
 ifeq (1, $(ASSERT))
@@ -50,6 +56,55 @@ else
    LLVM_OPTION += '-DLLVM_ENABLE_ASSERTIONS=OFF'
 endif

+ifeq (1, $(STATIC))
+    # Build TinyGo as a fully statically linked binary (no dynamically loaded
+    # libraries such as a libc). This is not supported with glibc which is used
+    # on most major Linux distributions. However, it is supported in Alpine
+    # Linux with musl.
+    CGO_LDFLAGS += -static
+    # Also set the thread stack size to 1MB. This is necessary on musl as the
+    # default stack size is 128kB and LLVM uses more than that.
+    # For more information, see:
+    # https://wiki.musl-libc.org/functional-differences-from-glibc.html#Thread-stack-size
+    CGO_LDFLAGS += -Wl,-z,stack-size=1048576
+    # Build wasm-opt with static linking.
+    # For details, see:
+    # https://github.com/WebAssembly/binaryen/blob/version_102/.github/workflows/ci.yml#L181
+    BINARYEN_OPTION += -DCMAKE_CXX_FLAGS="-static" -DCMAKE_C_FLAGS="-static"
+endif
+
+# Cross compiling support.
+ifneq ($(CROSS),)
+    CC = $(CROSS)-gcc
+    CXX = $(CROSS)-g++
+    LLVM_OPTION += \
+        -DCMAKE_C_COMPILER=$(CC) \
+        -DCMAKE_CXX_COMPILER=$(CXX) \
+        -DLLVM_DEFAULT_TARGET_TRIPLE=$(CROSS) \
+        -DCROSS_TOOLCHAIN_FLAGS_NATIVE="-UCMAKE_C_COMPILER;-UCMAKE_CXX_COMPILER"
+    ifeq ($(CROSS), arm-linux-gnueabihf)
+        # Assume we're building on a Debian-like distro, with QEMU installed.
+        LLVM_CONFIG_PREFIX = qemu-arm -L /usr/arm-linux-gnueabihf/
+        # The CMAKE_SYSTEM_NAME flag triggers cross compilation mode.
+        LLVM_OPTION += \
+            -DCMAKE_SYSTEM_NAME=Linux \
+            -DLLVM_TARGET_ARCH=ARM
+        GOENVFLAGS = GOARCH=arm CC=$(CC) CXX=$(CXX) CGO_ENABLED=1
+        BINARYEN_OPTION += -DCMAKE_C_COMPILER=$(CC) -DCMAKE_CXX_COMPILER=$(CXX)
+    else ifeq ($(CROSS), aarch64-linux-gnu)
+        # Assume we're building on a Debian-like distro, with QEMU installed.
+        LLVM_CONFIG_PREFIX = qemu-aarch64 -L /usr/aarch64-linux-gnu/
+        # The CMAKE_SYSTEM_NAME flag triggers cross compilation mode.
+        LLVM_OPTION += \
+            -DCMAKE_SYSTEM_NAME=Linux \
+            -DLLVM_TARGET_ARCH=AArch64
+        GOENVFLAGS = GOARCH=arm64 CC=$(CC) CXX=$(CXX) CGO_ENABLED=1
+        BINARYEN_OPTION += -DCMAKE_C_COMPILER=$(CC) -DCMAKE_CXX_COMPILER=$(CXX)
+    else
+        $(error Unknown cross compilation target: $(CROSS))
+    endif
+endif
+
 .PHONY: all tinygo test $(LLVM_BUILDDIR) llvm-source clean fmt gen-device gen-device-nrf gen-device-nxp gen-device-avr gen-device-rp

 LLVM_COMPONENTS = all-targets analysis asmparser asmprinter bitreader bitwriter codegen core coroutines coverage debuginfodwarf debuginfopdb executionengine frontendopenmp instrumentation interpreter ipo irreader libdriver linker lto mc mcjit objcarcopts option profiledata scalaropts support target windowsmanifest
@@ -73,6 +128,8 @@ ifeq ($(OS),Windows_NT)
 else ifeq ($(shell uname -s),Darwin)
    MD5SUM = md5

+    CGO_LDFLAGS += -lxar
+
    USE_SYSTEM_BINARYEN ?= 1

 else ifeq ($(shell uname -s),FreeBSD)
@@ -89,11 +146,11 @@ CLANG_LIB_NAMES = clangAnalysis clangAST clangASTMatchers clangBasic clangCodeGe
 CLANG_LIBS = $(START_GROUP) $(addprefix -l,$(CLANG_LIB_NAMES)) $(END_GROUP) -lstdc++

 # Libraries that should be linked in for the statically linked LLD.
-LLD_LIB_NAMES = lldCOFF lldCommon lldCore lldDriver lldELF lldMachO lldMinGW lldReaderWriter lldWasm lldYAML
+LLD_LIB_NAMES = lldCOFF lldCommon lldELF lldMachO lldMinGW lldWasm
 LLD_LIBS = $(START_GROUP) $(addprefix -l,$(LLD_LIB_NAMES)) $(END_GROUP)

 # Other libraries that are needed to link TinyGo.
-EXTRA_LIB_NAMES = LLVMInterpreter
+EXTRA_LIB_NAMES = LLVMInterpreter LLVMMCA LLVMX86TargetMCA

 # 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)
@@ -108,15 +165,15 @@ NINJA_BUILD_TARGETS = clang llvm-config llvm-ar llvm-nm $(addprefix lib/lib,$(ad

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

 clean:
 	@rm -rf build

-FMT_PATHS = ./*.go builder cgo compiler interp loader src/device/arm src/examples src/machine src/os src/reflect src/runtime src/sync src/syscall src/testing src/internal/reflectlite transform
+FMT_PATHS = ./*.go builder cgo/*.go compiler interp loader src transform
 fmt:
 	@gofmt -l -w $(FMT_PATHS)
 fmt-check:
@@ -173,12 +230,12 @@ 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_14.0.0-patched --depth=1 https://github.com/tinygo-org/llvm-project $(LLVM_PROJECTDIR)
 llvm-source: $(LLVM_PROJECTDIR)/llvm

 # Configure LLVM.
 TINYGO_SOURCE_DIR=$(shell pwd)
-$(LLVM_BUILDDIR)/build.ninja: llvm-source
+$(LLVM_BUILDDIR)/build.ninja:
 	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.
@@ -200,31 +257,29 @@ endif
 wasi-libc: lib/wasi-libc/sysroot/lib/wasm32-wasi/libc.a
 lib/wasi-libc/sysroot/lib/wasm32-wasi/libc.a:
 	@if [ ! -e lib/wasi-libc/Makefile ]; then echo "Submodules have not been downloaded. Please download them using:\n  git submodule update --init"; exit 1; fi
-	cd lib/wasi-libc && make -j4 WASM_CFLAGS="-O2 -g -DNDEBUG" WASM_CC=$(CLANG) WASM_AR=$(LLVM_AR) WASM_NM=$(LLVM_NM)
+	cd lib/wasi-libc && make -j4 WASM_CFLAGS="-O2 -g -DNDEBUG -mnontrapping-fptoint -msign-ext" MALLOC_IMPL=none CC=$(CLANG) AR=$(LLVM_AR) NM=$(LLVM_NM)


 # Build the Go compiler.
 tinygo:
 	@if [ ! -f "$(LLVM_BUILDDIR)/bin/llvm-config" ]; then echo "Fetch and build LLVM first by running:"; echo "  make llvm-source"; echo "  make $(LLVM_BUILDDIR)"; exit 1; fi
-	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) build -buildmode exe -o build/tinygo$(EXE) -tags byollvm -ldflags="-X main.gitSha1=`git rev-parse --short HEAD`" .
-
+	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GOENVFLAGS) $(GO) build -buildmode exe -o build/tinygo$(EXE) -tags "byollvm osusergo" -ldflags="-X github.com/tinygo-org/tinygo/goenv.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 $(GOTESTFLAGS) -timeout=20m -buildmode exe -tags "byollvm osusergo" ./builder ./cgo ./compileopts ./compiler ./interp ./transform .

-# Tests that take over a minute in wasi
+# Standard library packages that pass tests on darwin, linux, wasi, and windows, but take over a minute in wasi
 TEST_PACKAGES_SLOW = \
 	compress/bzip2 \
-	compress/flate \
 	crypto/dsa \
 	index/suffixarray \

-TEST_PACKAGES_BASE = \
+# Standard library packages that pass tests quickly on darwin, linux, wasi, and windows
+TEST_PACKAGES_FAST = \
 	compress/zlib \
 	container/heap \
 	container/list \
 	container/ring \
 	crypto/des \
-	crypto/elliptic/internal/fiat \
 	crypto/internal/subtle \
 	crypto/md5 \
 	crypto/rc4 \
@@ -232,6 +287,7 @@ TEST_PACKAGES_BASE = \
 	crypto/sha256 \
 	crypto/sha512 \
 	debug/macho \
+	embed/internal/embedtest \
 	encoding \
 	encoding/ascii85 \
 	encoding/base32 \
@@ -247,6 +303,7 @@ TEST_PACKAGES_BASE = \
 	internal/profile \
 	math \
 	math/cmplx \
+	net \
 	net/http/internal/ascii \
 	net/mail \
 	os \
@@ -259,41 +316,92 @@ TEST_PACKAGES_BASE = \
 	unicode \
 	unicode/utf16 \
 	unicode/utf8 \
+	$(nil)

-# 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
+# Assume this will go away before Go2, so only check minor version.
+ifeq ($(filter $(shell $(GO) env GOVERSION | cut -f 2 -d.), 16 17 18), )
+TEST_PACKAGES_FAST += crypto/internal/nistec/fiat
+else
+TEST_PACKAGES_FAST += crypto/elliptic/internal/fiat
 endif

-# Standard library packages that pass tests on wasi
-TEST_PACKAGES_WASI = \
-	$(TEST_PACKAGES_BASE)
+# archive/zip requires os.ReadAt, which is not yet supported on windows
+# compress/flate appears to hang on wasi
+# compress/lzw appears to hang on wasi
+# crypto/hmac fails on wasi, it exits with a "slice out of range" panic
+# debug/plan9obj requires os.ReadAt, which is not yet supported on windows
+# io/fs requires os.ReadDir, which is not yet supported on windows or wasi
+# io/ioutil requires os.ReadDir, which is not yet supported on windows or wasi
+# strconv requires recover() which is not yet supported on wasi
+# text/template/parse requires recover(), which is not yet supported on wasi
+# testing/fstest requires os.ReadDir, which is not yet supported on windows or wasi
+
+# Additional standard library packages that pass tests on individual platforms
+TEST_PACKAGES_LINUX := \
+	archive/zip \
+	compress/flate \
+	compress/lzw \
+	crypto/hmac \
+	debug/dwarf \
+	debug/plan9obj \
+	io/fs \
+	io/ioutil \
+	strconv \
+	testing/fstest \
+	text/template/parse
+
+TEST_PACKAGES_DARWIN := $(TEST_PACKAGES_LINUX)
+
+TEST_PACKAGES_WINDOWS := \
+	compress/flate \
+	compress/lzw \
+	crypto/hmac \
+	strconv \
+	text/template/parse \
+	$(nil)
+
+# Report platforms on which each standard library package is known to pass tests
+jointmp := $(shell echo /tmp/join.$$$$)
+report-stdlib-tests-pass:
+	@for t in $(TEST_PACKAGES_DARWIN); do echo "$$t darwin"; done | sort > $(jointmp).darwin
+	@for t in $(TEST_PACKAGES_LINUX); do echo "$$t linux"; done | sort > $(jointmp).linux
+	@for t in $(TEST_PACKAGES_FAST) $(TEST_PACKAGES_SLOW); do echo "$$t darwin linux wasi windows"; done | sort > $(jointmp).portable
+	@join -a1 -a2 $(jointmp).darwin $(jointmp).linux | \
+	join -a1 -a2 - $(jointmp).portable
+	@rm $(jointmp).*
+
+# Standard library packages that pass tests quickly on the current platform
+ifeq ($(shell uname),Darwin)
+TEST_PACKAGES_HOST := $(TEST_PACKAGES_FAST) $(TEST_PACKAGES_DARWIN)
+endif
+ifeq ($(shell uname),Linux)
+TEST_PACKAGES_HOST := $(TEST_PACKAGES_FAST) $(TEST_PACKAGES_LINUX)
+endif
+ifeq ($(OS),Windows_NT)
+TEST_PACKAGES_HOST := $(TEST_PACKAGES_FAST) $(TEST_PACKAGES_WINDOWS)
+endif

 # 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 $(TEST_PACKAGES_HOST) $(TEST_PACKAGES_SLOW)
 tinygo-test-fast:
-	$(TINYGO) test $(TEST_PACKAGES)
+	$(TINYGO) test $(TEST_PACKAGES_HOST)
 tinygo-bench:
-	$(TINYGO) test -bench . $(TEST_PACKAGES) $(TEST_PACKAGES_SLOW)
+	$(TINYGO) test -bench . $(TEST_PACKAGES_HOST) $(TEST_PACKAGES_SLOW)
 tinygo-bench-fast:
-	$(TINYGO) test -bench . $(TEST_PACKAGES)
+	$(TINYGO) test -bench . $(TEST_PACKAGES_HOST)
+
+# Same thing, except for wasi rather than the current platform.
 tinygo-test-wasi:
-	$(TINYGO) test -target wasi $(TEST_PACKAGES_WASI) $(TEST_PACKAGES_SLOW)
+	$(TINYGO) test -target wasi $(TEST_PACKAGES_FAST) $(TEST_PACKAGES_SLOW) ./tests/runtime_wasi
 tinygo-test-wasi-fast:
-	$(TINYGO) test -target wasi $(TEST_PACKAGES_WASI)
+	$(TINYGO) test -target wasi $(TEST_PACKAGES_FAST) ./tests/runtime_wasi
 tinygo-bench-wasi:
-	$(TINYGO) test -target wasi -bench . $(TEST_PACKAGES_WASI) $(TEST_PACKAGES_SLOW)
+	$(TINYGO) test -target wasi -bench . $(TEST_PACKAGES_FAST) $(TEST_PACKAGES_SLOW)
 tinygo-bench-wasi-fast:
-	$(TINYGO) test -target wasi -bench . $(TEST_PACKAGES_WASI)
+	$(TINYGO) test -target wasi -bench . $(TEST_PACKAGES_FAST)

 # Test external packages in a large corpus.
 test-corpus:
@@ -303,10 +411,19 @@ test-corpus-fast:
 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

+tinygo-baremetal:
+	# Regression tests that run on a baremetal target and don't fit in either main_test.go or smoketest.
+	# regression test for #2666: e.g. encoding/hex must pass on baremetal
+	$(TINYGO) test -target cortex-m-qemu encoding/hex

 .PHONY: smoketest
 smoketest:
 	$(TINYGO) version
+	$(TINYGO) targets > /dev/null
+	# regression test for #2892
+	cd tests/testing/recurse && ($(TINYGO) test ./... > recurse.log && cat recurse.log && test $$(wc -l < recurse.log) = 2 && rm recurse.log)
+	# compile-only platform-independent examples
+	cd tests/text/template/smoke && $(TINYGO) test -c && rm -f smoke.test
 	# regression test for #2563
 	cd tests/os/smoke && $(TINYGO) test -c -target=pybadge && rm smoke.test
 	# test all examples (except pwm)
@@ -324,6 +441,8 @@ smoketest:
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/echo
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/echo2
+	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=circuitplay-express examples/i2s
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/mcp3008
@@ -340,6 +459,10 @@ smoketest:
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/test
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=wioterminal         examples/hid-mouse
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=wioterminal         examples/hid-keyboard
+	@$(MD5SUM) test.hex
 	# test simulated boards on play.tinygo.org
 ifneq ($(WASM), 0)
 	$(TINYGO) build -size short -o test.wasm -tags=arduino              examples/blinky1
@@ -348,12 +471,14 @@ ifneq ($(WASM), 0)
 	@$(MD5SUM) test.wasm
 	$(TINYGO) build -size short -o test.wasm -tags=reelboard            examples/blinky1
 	@$(MD5SUM) test.wasm
-	$(TINYGO) build -size short -o test.wasm -tags=pca10040             examples/blinky2
-	@$(MD5SUM) test.wasm
-	$(TINYGO) build -size short -o test.wasm -tags=pca10056             examples/blinky2
+	$(TINYGO) build -size short -o test.wasm -tags=microbit             examples/microbit-blink
 	@$(MD5SUM) test.wasm
 	$(TINYGO) build -size short -o test.wasm -tags=circuitplay_express  examples/blinky1
 	@$(MD5SUM) test.wasm
+	$(TINYGO) build -size short -o test.wasm -tags=circuitplay_bluefruit examples/blinky1
+	@$(MD5SUM) test.wasm
+	$(TINYGO) build -size short -o test.wasm -tags=mch2022              examples/serial
+	@$(MD5SUM) test.wasm
 endif
 	# test all targets/boards
 	$(TINYGO) build -size short -o test.hex -target=pca10040-s132v6     examples/blinky1
@@ -404,6 +529,8 @@ endif
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=feather-m4          examples/blinky1
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=matrixportal-m4     examples/blinky1
+	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pybadge             examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=metro-m4-airlift    examples/blinky1
@@ -442,6 +569,8 @@ endif
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=qtpy                examples/serial
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=teensy41            examples/blinky1
+	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=teensy40            examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=teensy36            examples/blinky1
@@ -468,6 +597,22 @@ endif
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=feather-rp2040 		examples/blinky1
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=qtpy-rp2040         examples/echo
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=macropad-rp2040 	examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=badger2040          examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=tufty2040           examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=thingplus-rp2040    examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=xiao-rp2040         examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=challenger-rp2040    examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=trinkey-qt2040      examples/adc_rp2040
+	@$(MD5SUM) test.hex
 	# test pwm
 	$(TINYGO) build -size short -o test.hex -target=itsybitsy-m0        examples/pwm
 	@$(MD5SUM) test.hex
@@ -475,6 +620,13 @@ endif
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=feather-m4          examples/pwm
 	@$(MD5SUM) test.hex
+	# test usb
+	$(TINYGO) build -size short -o test.hex -target=feather-nrf52840    examples/hid-keyboard
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=circuitplay-express examples/hid-keyboard
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=feather-nrf52840    examples/usb-midi
+	@$(MD5SUM) test.hex
 ifneq ($(STM32), 0)
 	$(TINYGO) build -size short -o test.hex -target=bluepill            examples/blinky1
 	@$(MD5SUM) test.hex
@@ -538,15 +690,19 @@ ifneq ($(XTENSA), 0)
 	@$(MD5SUM) test.bin
 	$(TINYGO) build -size short -o test.bin -target m5stack             examples/serial
 	@$(MD5SUM) test.bin
+	$(TINYGO) build -size short -o test.bin -target mch2022             examples/serial
+	@$(MD5SUM) test.bin
 endif
-	$(TINYGO) build -size short -o test.bin -target=esp32c3           	examples/serial
+	$(TINYGO) build -size short -o test.bin -target=esp32c3             examples/serial
+	@$(MD5SUM) test.bin
+	$(TINYGO) build -size short -o test.bin -target=esp32c3-12f         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.bin -target=xiao-esp32c3        examples/serial
+	@$(MD5SUM) test.bin
 	$(TINYGO) build -size short -o test.hex -target=hifive1b            examples/blinky1
 	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=hifive1-qemu        examples/serial
-	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=maixbit             examples/blinky1
 	@$(MD5SUM) test.hex
 ifneq ($(WASM), 0)
@@ -566,6 +722,8 @@ endif
 	@$(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=darwin GOARCH=amd64 $(TINYGO) build  -size short -o test       ./testdata/cgo
+	GOOS=darwin GOARCH=arm64 $(TINYGO) build  -size short -o test       ./testdata/cgo
 ifneq ($(OS),Windows_NT)
 	# TODO: this does not yet work on Windows. Somehow, unused functions are
 	# not garbage collected.
@@ -580,7 +738,7 @@ build/release: tinygo gen-device wasi-libc $(if $(filter 1,$(USE_SYSTEM_BINARYEN
 	@mkdir -p build/release/tinygo/bin
 	@mkdir -p build/release/tinygo/lib/clang/include
 	@mkdir -p build/release/tinygo/lib/CMSIS/CMSIS
-	@mkdir -p build/release/tinygo/lib/compiler-rt/lib
+	@mkdir -p build/release/tinygo/lib/macos-minimal-sdk
 	@mkdir -p build/release/tinygo/lib/mingw-w64/mingw-w64-crt/lib-common
 	@mkdir -p build/release/tinygo/lib/mingw-w64/mingw-w64-headers/defaults
 	@mkdir -p build/release/tinygo/lib/musl/arch
@@ -601,9 +759,7 @@ endif
 	@cp -p $(abspath $(CLANG_SRC))/lib/Headers/*.h build/release/tinygo/lib/clang/include
 	@cp -rp lib/CMSIS/CMSIS/Include      build/release/tinygo/lib/CMSIS/CMSIS
 	@cp -rp lib/CMSIS/README.md          build/release/tinygo/lib/CMSIS
-	@cp -rp lib/compiler-rt/lib/builtins build/release/tinygo/lib/compiler-rt/lib
-	@cp -rp lib/compiler-rt/LICENSE.TXT  build/release/tinygo/lib/compiler-rt
-	@cp -rp lib/compiler-rt/README.txt   build/release/tinygo/lib/compiler-rt
+	@cp -rp lib/macos-minimal-sdk/*      build/release/tinygo/lib/macos-minimal-sdk
 	@cp -rp lib/musl/arch/aarch64        build/release/tinygo/lib/musl/arch
 	@cp -rp lib/musl/arch/arm            build/release/tinygo/lib/musl/arch
 	@cp -rp lib/musl/arch/generic        build/release/tinygo/lib/musl/arch
@@ -619,6 +775,7 @@ endif
 	@cp -rp lib/musl/src/internal        build/release/tinygo/lib/musl/src
 	@cp -rp lib/musl/src/malloc          build/release/tinygo/lib/musl/src
 	@cp -rp lib/musl/src/mman            build/release/tinygo/lib/musl/src
+	@cp -rp lib/musl/src/math            build/release/tinygo/lib/musl/src
 	@cp -rp lib/musl/src/signal          build/release/tinygo/lib/musl/src
 	@cp -rp lib/musl/src/stdio           build/release/tinygo/lib/musl/src
 	@cp -rp lib/musl/src/string          build/release/tinygo/lib/musl/src
@@ -637,23 +794,32 @@ endif
 	@cp -rp lib/picolibc/newlib/libc/string      build/release/tinygo/lib/picolibc/newlib/libc
 	@cp -rp lib/picolibc/newlib/libc/tinystdio   build/release/tinygo/lib/picolibc/newlib/libc
 	@cp -rp lib/picolibc/newlib/libm/common      build/release/tinygo/lib/picolibc/newlib/libm
+	@cp -rp lib/picolibc/newlib/libm/math        build/release/tinygo/lib/picolibc/newlib/libm
 	@cp -rp lib/picolibc-stdio.c         build/release/tinygo/lib
 	@cp -rp lib/wasi-libc/sysroot        build/release/tinygo/lib/wasi-libc/sysroot
+	@cp -rp llvm-project/compiler-rt/lib/builtins build/release/tinygo/lib/compiler-rt-builtins
+	@cp -rp llvm-project/compiler-rt/LICENSE.TXT  build/release/tinygo/lib/compiler-rt-builtins
 	@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/release/tinygo/bin/tinygo build-library -target=cortex-m0     -o build/release/tinygo/pkg/thumbv6m-unknown-unknown-eabi-cortex-m0/compiler-rt     compiler-rt
+	./build/release/tinygo/bin/tinygo build-library -target=cortex-m0plus -o build/release/tinygo/pkg/thumbv6m-unknown-unknown-eabi-cortex-m0plus/compiler-rt compiler-rt
+	./build/release/tinygo/bin/tinygo build-library -target=cortex-m4     -o build/release/tinygo/pkg/thumbv7em-unknown-unknown-eabi-cortex-m4/compiler-rt    compiler-rt
+	./build/release/tinygo/bin/tinygo build-library -target=cortex-m0     -o build/release/tinygo/pkg/thumbv6m-unknown-unknown-eabi-cortex-m0/picolibc     picolibc
+	./build/release/tinygo/bin/tinygo build-library -target=cortex-m0plus -o build/release/tinygo/pkg/thumbv6m-unknown-unknown-eabi-cortex-m0plus/picolibc picolibc
+	./build/release/tinygo/bin/tinygo build-library -target=cortex-m4     -o build/release/tinygo/pkg/thumbv7em-unknown-unknown-eabi-cortex-m4/picolibc    picolibc

-release: build/release
+release:
 	tar -czf build/release.tar.gz -C build/release tinygo

-deb: build/release
+DEB_ARCH ?= native
+deb:
 	@mkdir -p build/release-deb/usr/local/bin
 	@mkdir -p build/release-deb/usr/local/lib
 	cp -ar build/release/tinygo build/release-deb/usr/local/lib/tinygo
 	ln -sf ../lib/tinygo/bin/tinygo build/release-deb/usr/local/bin/tinygo
-	fpm -f -s dir -t deb -n tinygo -v $(shell grep "const Version = " goenv/version.go | awk '{print $$NF}') -m '@tinygo-org' --description='TinyGo is a Go compiler for small places.' --license='BSD 3-Clause' --url=https://tinygo.org/ --deb-changelog CHANGELOG.md -p build/release.deb -C ./build/release-deb
+	fpm -f -s dir -t deb -n tinygo -a $(DEB_ARCH) -v $(shell grep "const Version = " goenv/version.go | awk '{print $$NF}') -m '@tinygo-org' --description='TinyGo is a Go compiler for small places.' --license='BSD 3-Clause' --url=https://tinygo.org/ --deb-changelog CHANGELOG.md -p build/release.deb -C ./build/release-deb
+
+ifneq ($(RELEASEONLY), 1)
+release: build/release
+deb: build/release
+endif
@@ -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 91 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)
@@ -59,13 +59,16 @@ The following 80 microcontroller boards are currently supported:
 * [Adafruit ItsyBitsy M0](https://www.adafruit.com/product/3727)
 * [Adafruit ItsyBitsy M4](https://www.adafruit.com/product/3800)
 * [Adafruit ItsyBitsy nRF52840](https://www.adafruit.com/product/4481)
+* [Adafruit MacroPad RP2040](https://www.adafruit.com/product/5100)
 * [Adafruit Matrix Portal M4](https://www.adafruit.com/product/4745)
 * [Adafruit Metro M4 Express Airlift](https://www.adafruit.com/product/4000)
 * [Adafruit PyBadge](https://www.adafruit.com/product/4200)
 * [Adafruit PyGamer](https://www.adafruit.com/product/4242)
 * [Adafruit PyPortal](https://www.adafruit.com/product/4116)
 * [Adafruit QT Py](https://www.adafruit.com/product/4600)
+* [Adafruit QT Py RP2040](https://www.adafruit.com/product/4900)
 * [Adafruit Trinket M0](https://www.adafruit.com/product/3500)
+* [Adafruit Trinkey QT2040](https://adafruit.com/product/5056)
 * [Arduino Mega 1280](https://www.arduino.cc/en/Main/arduinoBoardMega/)
 * [Arduino Mega 2560](https://store.arduino.cc/arduino-mega-2560-rev3)
 * [Arduino MKR1000](https://store.arduino.cc/arduino-mkr1000-wifi)
@@ -84,14 +87,17 @@ The following 80 microcontroller boards are currently supported:
 * [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)
+* [ESP32-C3-12f](https://www.espressif.com/en/products/socs/esp32-c3)
 * [ESP8266 - d1mini](https://www.espressif.com/en/products/socs/esp8266)
 * [ESP8266 - NodeMCU](https://www.espressif.com/en/products/socs/esp8266)
 * [Game Boy Advance](https://en.wikipedia.org/wiki/Game_Boy_Advance)
+* [iLabs Challenger RP2040 LoRa](https://ilabs.se/product/challenger-rp2040-lora/)
 * [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/)
+* [MCH2022 badge](https://badge.team/docs/badges/mch2022/)
 * [Microchip SAM E54 Xplained Pro](https://www.microchip.com/developmenttools/productdetails/atsame54-xpro)
 * [nice!nano](https://docs.nicekeyboards.com/#/nice!nano/)
 * [Nintendo Switch](https://www.nintendo.com/switch/)
@@ -103,17 +109,24 @@ The following 80 microcontroller boards are currently supported:
 * [Particle Boron](https://docs.particle.io/datasheets/cellular/boron-datasheet/)
 * [Particle Xenon](https://docs.particle.io/datasheets/discontinued/xenon-datasheet/)
 * [Phytec reel board](https://www.phytec.eu/product-eu/internet-of-things/reelboard/)
+* [Pimoroni Badger2040](https://shop.pimoroni.com/products/badger-2040)
+* [Pimoroni Tufty2040](https://shop.pimoroni.com/products/tufty-2040)
 * [PineTime DevKit](https://www.pine64.org/pinetime/)
 * [PJRC Teensy 3.6](https://www.pjrc.com/store/teensy36.html)
 * [PJRC Teensy 4.0](https://www.pjrc.com/store/teensy40.html)
+* [PJRC Teensy 4.1](https://www.pjrc.com/store/teensy41.html)
 * [ProductivityOpen P1AM-100](https://facts-engineering.github.io/modules/P1AM-100/P1AM-100.html)
 * [Raspberry Pi Pico](https://www.raspberrypi.org/products/raspberry-pi-pico/)
 * [Raytac MDBT50Q-RX Dongle (with TinyUF2 bootloader)](https://www.adafruit.com/product/5199)
 * [Seeed Seeeduino XIAO](https://www.seeedstudio.com/Seeeduino-XIAO-Arduino-Microcontroller-SAMD21-Cortex-M0+-p-4426.html)
+* [Seeed XIAO BLE](https://www.seeedstudio.com/Seeed-XIAO-BLE-nRF52840-p-5201.html)
+* [Seeed XIAO ESP32C3](https://www.seeedstudio.com/Seeed-XIAO-ESP32C3-p-5431.html)
+* [Seeed XIAO RP2040](https://www.seeedstudio.com/XIAO-RP2040-v1-0-p-5026.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)
+* [SiFIve HiFive1 Rev B](https://www.sifive.com/boards/hifive1-rev-b)
+* [Sparkfun Thing Plus RP2040](https://www.sparkfun.com/products/17745)
 * [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)
@@ -18,7 +18,7 @@ import (
 // makeArchive creates an arcive for static linking from a list of object files
 // given as a parameter. It is equivalent to the following command:
 //
-//     ar -rcs <archivePath> <objs...>
+//	ar -rcs <archivePath> <objs...>
 func makeArchive(arfile *os.File, objs []string) error {
 	// Open the archive file.
 	arwriter := ar.NewWriter(arfile)
@@ -4,6 +4,7 @@
 package builder

 import (
+	"crypto/sha256"
 	"crypto/sha512"
 	"debug/elf"
 	"encoding/binary"
@@ -13,7 +14,7 @@ import (
 	"fmt"
 	"go/types"
 	"hash/crc32"
-	"io/ioutil"
+	"io/fs"
 	"math/bits"
 	"os"
 	"os/exec"
@@ -37,8 +38,14 @@ import (
 // BuildResult is the output of a build. This includes the binary itself and
 // some other metadata that is obtained while building the binary.
 type BuildResult struct {
+	// The executable directly from the linker, usually including debug
+	// information. Used for GDB for example.
+	Executable string
+
 	// A path to the output binary. It will be removed after Build returns, so
 	// if it should be kept it must be copied or moved away.
+	// It is often the same as Executable, but differs if the output format is
+	// .hex for example (instead of the usual ELF).
 	Binary string

 	// The directory of the main package. This is useful for testing as the test
@@ -74,6 +81,7 @@ type packageAction struct {
 	Config           *compiler.Config
 	CFlags           []string
 	FileHashes       map[string]string // hash of every file that's part of the package
+	EmbeddedFiles    map[string]string // hash of all the //go:embed files in the package
 	Imports          map[string]string // map from imported package to action ID hash
 	OptLevel         int               // LLVM optimization level (0-3)
 	SizeLevel        int               // LLVM optimization for size level (0-2)
@@ -95,11 +103,24 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 	}

 	// Create a temporary directory for intermediary files.
-	dir, err := ioutil.TempDir("", "tinygo")
+	dir, err := os.MkdirTemp("", "tinygo")
 	if err != nil {
 		return err
 	}
-	defer os.RemoveAll(dir)
+	if config.Options.Work {
+		fmt.Printf("WORK=%s\n", dir)
+	} else {
+		defer os.RemoveAll(dir)
+	}
+
+	// Look up the build cache directory, which is used to speed up incremental
+	// builds.
+	cacheDir := goenv.Get("GOCACHE")
+	if cacheDir == "off" {
+		// Use temporary build directory instead, effectively disabling the
+		// build cache.
+		cacheDir = dir
+	}

 	// Check for a libc dependency.
 	// As a side effect, this also creates the headers for the given libc, if
@@ -107,6 +128,9 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 	root := goenv.Get("TINYGOROOT")
 	var libcDependencies []*compileJob
 	switch config.Target.Libc {
+	case "darwin-libSystem":
+		job := makeDarwinLibSystemJob(config, dir)
+		libcDependencies = append(libcDependencies, job)
 	case "musl":
 		job, unlock, err := Musl.load(config, dir)
 		if err != nil {
@@ -124,7 +148,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		libcDependencies = append(libcDependencies, libcJob)
 	case "wasi-libc":
 		path := filepath.Join(root, "lib/wasi-libc/sysroot/lib/wasm32-wasi/libc.a")
-		if _, err := os.Stat(path); os.IsNotExist(err) {
+		if _, err := os.Stat(path); errors.Is(err, fs.ErrNotExist) {
 			return errors.New("could not find wasi-libc, perhaps you need to run `make wasi-libc`?")
 		}
 		libcDependencies = append(libcDependencies, dummyCompileJob(path))
@@ -166,9 +190,10 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 	if err != nil {
 		return err
 	}
+	defer machine.Dispose()

 	// Load entire program AST into memory.
-	lprogram, err := loader.Load(config, []string{pkgName}, config.ClangHeaders, types.Config{
+	lprogram, err := loader.Load(config, pkgName, config.ClangHeaders, types.Config{
 		Sizes: compiler.Sizes(machine),
 	})
 	if err != nil {
@@ -186,8 +211,23 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 	// Add jobs to compile each package.
 	// Packages that have a cache hit will not be compiled again.
 	var packageJobs []*compileJob
-	packageBitcodePaths := make(map[string]string)
-	packageActionIDs := make(map[string]string)
+	packageActionIDJobs := make(map[string]*compileJob)
+
+	if config.Options.GlobalValues["runtime"]["buildVersion"] == "" {
+		version := goenv.Version
+		if strings.HasSuffix(goenv.Version, "-dev") && goenv.GitSha1 != "" {
+			version += "-" + goenv.GitSha1
+		}
+		if config.Options.GlobalValues == nil {
+			config.Options.GlobalValues = make(map[string]map[string]string)
+		}
+		if config.Options.GlobalValues["runtime"] == nil {
+			config.Options.GlobalValues["runtime"] = make(map[string]string)
+		}
+		config.Options.GlobalValues["runtime"]["buildVersion"] = version
+	}
+
+	var embedFileObjects []*compileJob
 	for _, pkg := range lprogram.Sorted() {
 		pkg := pkg // necessary to avoid a race condition

@@ -197,58 +237,114 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		}
 		sort.Strings(undefinedGlobals)

-		// Create a cache key: a hash from the action ID below that contains all
-		// the parameters for the build.
-		actionID := packageAction{
-			ImportPath:       pkg.ImportPath,
-			CompilerBuildID:  string(compilerBuildID),
-			TinyGoVersion:    goenv.Version,
-			LLVMVersion:      llvm.Version,
-			Config:           compilerConfig,
-			CFlags:           pkg.CFlags,
-			FileHashes:       make(map[string]string, len(pkg.FileHashes)),
-			Imports:          make(map[string]string, len(pkg.Pkg.Imports())),
-			OptLevel:         optLevel,
-			SizeLevel:        sizeLevel,
-			UndefinedGlobals: undefinedGlobals,
+		// Make compile jobs to load files to be embedded in the output binary.
+		var actionIDDependencies []*compileJob
+		allFiles := map[string][]*loader.EmbedFile{}
+		for _, files := range pkg.EmbedGlobals {
+			for _, file := range files {
+				allFiles[file.Name] = append(allFiles[file.Name], file)
+			}
 		}
-		for filePath, hash := range pkg.FileHashes {
-			actionID.FileHashes[filePath] = hex.EncodeToString(hash)
+		for name, files := range allFiles {
+			name := name
+			files := files
+			job := &compileJob{
+				description: "make object file for " + name,
+				run: func(job *compileJob) error {
+					// Read the file contents in memory.
+					path := filepath.Join(pkg.Dir, name)
+					data, err := os.ReadFile(path)
+					if err != nil {
+						return err
+					}
+
+					// Hash the file.
+					sum := sha256.Sum256(data)
+					hexSum := hex.EncodeToString(sum[:16])
+
+					for _, file := range files {
+						file.Size = uint64(len(data))
+						file.Hash = hexSum
+						if file.NeedsData {
+							file.Data = data
+						}
+					}
+
+					job.result, err = createEmbedObjectFile(string(data), hexSum, name, pkg.OriginalDir(), dir, compilerConfig)
+					return err
+				},
+			}
+			actionIDDependencies = append(actionIDDependencies, job)
+			embedFileObjects = append(embedFileObjects, job)
 		}
+
+		// Action ID jobs need to know the action ID of all the jobs the package
+		// imports.
+		var importedPackages []*compileJob
 		for _, imported := range pkg.Pkg.Imports() {
-			hash, ok := packageActionIDs[imported.Path()]
+			job, ok := packageActionIDJobs[imported.Path()]
 			if !ok {
 				return fmt.Errorf("package %s imports %s but couldn't find dependency", pkg.ImportPath, imported.Path())
 			}
-			actionID.Imports[imported.Path()] = hash
+			importedPackages = append(importedPackages, job)
+			actionIDDependencies = append(actionIDDependencies, job)
 		}
-		buf, err := json.Marshal(actionID)
-		if err != nil {
-			panic(err) // shouldn't happen
-		}
-		hash := sha512.Sum512_224(buf)
-		packageActionIDs[pkg.ImportPath] = hex.EncodeToString(hash[:])

-		// Determine the path of the bitcode file (which is a serialized version
-		// of a LLVM module).
-		cacheDir := goenv.Get("GOCACHE")
-		if cacheDir == "off" {
-			// Use temporary build directory instead, effectively disabling the
-			// build cache.
-			cacheDir = dir
+		// Create a job that will calculate the action ID for a package compile
+		// job. The action ID is the cache key that is used for caching this
+		// package.
+		packageActionIDJob := &compileJob{
+			description:  "calculate cache key for package " + pkg.ImportPath,
+			dependencies: actionIDDependencies,
+			run: func(job *compileJob) error {
+				// Create a cache key: a hash from the action ID below that contains all
+				// the parameters for the build.
+				actionID := packageAction{
+					ImportPath:       pkg.ImportPath,
+					CompilerBuildID:  string(compilerBuildID),
+					TinyGoVersion:    goenv.Version,
+					LLVMVersion:      llvm.Version,
+					Config:           compilerConfig,
+					CFlags:           pkg.CFlags,
+					FileHashes:       make(map[string]string, len(pkg.FileHashes)),
+					EmbeddedFiles:    make(map[string]string, len(allFiles)),
+					Imports:          make(map[string]string, len(pkg.Pkg.Imports())),
+					OptLevel:         optLevel,
+					SizeLevel:        sizeLevel,
+					UndefinedGlobals: undefinedGlobals,
+				}
+				for filePath, hash := range pkg.FileHashes {
+					actionID.FileHashes[filePath] = hex.EncodeToString(hash)
+				}
+				for name, files := range allFiles {
+					actionID.EmbeddedFiles[name] = files[0].Hash
+				}
+				for i, imported := range pkg.Pkg.Imports() {
+					actionID.Imports[imported.Path()] = importedPackages[i].result
+				}
+				buf, err := json.Marshal(actionID)
+				if err != nil {
+					return err // shouldn't happen
+				}
+				hash := sha512.Sum512_224(buf)
+				job.result = hex.EncodeToString(hash[:])
+				return nil
+			},
 		}
-		bitcodePath := filepath.Join(cacheDir, "pkg-"+hex.EncodeToString(hash[:])+".bc")
-		packageBitcodePaths[pkg.ImportPath] = bitcodePath
+		packageActionIDJobs[pkg.ImportPath] = packageActionIDJob

-		// The package has not yet been compiled, so create a job to do so.
+		// Now create the job to actually build the package. It will exit early
+		// if the package is already compiled.
 		job := &compileJob{
-			description: "compile package " + pkg.ImportPath,
-			run: func(*compileJob) error {
+			description:  "compile package " + pkg.ImportPath,
+			dependencies: []*compileJob{packageActionIDJob},
+			run: func(job *compileJob) error {
+				job.result = filepath.Join(cacheDir, "pkg-"+packageActionIDJob.result+".bc")
 				// Acquire a lock (if supported).
-				unlock := lock(bitcodePath + ".lock")
+				unlock := lock(job.result + ".lock")
 				defer unlock()

-				if _, err := os.Stat(bitcodePath); err == nil {
+				if _, err := os.Stat(job.result); err == nil {
 					// Already cached, don't recreate this package.
 					return nil
 				}
@@ -256,6 +352,8 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 				// 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())
+				defer mod.Context().Dispose()
+				defer mod.Dispose()
 				if errs != nil {
 					return newMultiError(errs)
 				}
@@ -272,7 +370,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 				// Packages are compiled independently anyway.
 				for _, cgoHeader := range pkg.CGoHeaders {
 					// Store the header text in a temporary file.
-					f, err := ioutil.TempFile(dir, "cgosnippet-*.c")
+					f, err := os.CreateTemp(dir, "cgosnippet-*.c")
 					if err != nil {
 						return err
 					}
@@ -333,7 +431,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 				if pkgInit.IsNil() {
 					panic("init not found for " + pkg.Pkg.Path())
 				}
-				err := interp.RunFunc(pkgInit, config.DumpSSA())
+				err := interp.RunFunc(pkgInit, config.Options.InterpTimeout, config.DumpSSA())
 				if err != nil {
 					return err
 				}
@@ -341,33 +439,13 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 					return errors.New("verification error after interpreting " + pkgInit.Name())
 				}

-				// Run function passes for each function in the module.
-				// These passes are intended to be run on each function right
-				// after they're created to reduce IR size (and maybe also for
-				// cache locality to improve performance), but for now they're
-				// run here for each function in turn. Maybe this can be
-				// improved in the future.
-				builder := llvm.NewPassManagerBuilder()
-				defer builder.Dispose()
-				builder.SetOptLevel(optLevel)
-				builder.SetSizeLevel(sizeLevel)
-				funcPasses := llvm.NewFunctionPassManagerForModule(mod)
-				defer funcPasses.Dispose()
-				builder.PopulateFunc(funcPasses)
-				funcPasses.InitializeFunc()
-				for fn := mod.FirstFunction(); !fn.IsNil(); fn = llvm.NextFunction(fn) {
-					if fn.IsDeclaration() {
-						continue
-					}
-					funcPasses.RunFunc(fn)
-				}
-				funcPasses.FinalizeFunc()
+				transform.OptimizePackage(mod, config)

 				// Serialize the LLVM module as a bitcode file.
 				// Write to a temporary path that is renamed to the destination
 				// file to avoid race conditions with other TinyGo invocatiosn
 				// that might also be compiling this package at the same time.
-				f, err := ioutil.TempFile(filepath.Dir(bitcodePath), filepath.Base(bitcodePath))
+				f, err := os.CreateTemp(filepath.Dir(job.result), filepath.Base(job.result))
 				if err != nil {
 					return err
 				}
@@ -387,13 +465,13 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 				if err != nil {
 					// WriteBitcodeToFile doesn't produce a useful error on its
 					// own, so create a somewhat useful error message here.
-					return fmt.Errorf("failed to write bitcode for package %s to file %s", pkg.ImportPath, bitcodePath)
+					return fmt.Errorf("failed to write bitcode for package %s to file %s", pkg.ImportPath, job.result)
 				}
 				err = f.Close()
 				if err != nil {
 					return err
 				}
-				return os.Rename(f.Name(), bitcodePath)
+				return os.Rename(f.Name(), job.result)
 			},
 		}
 		packageJobs = append(packageJobs, job)
@@ -401,6 +479,13 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil

 	// Add job that links and optimizes all packages together.
 	var mod llvm.Module
+	defer func() {
+		if !mod.IsNil() {
+			ctx := mod.Context()
+			mod.Dispose()
+			ctx.Dispose()
+		}
+	}()
 	var stackSizeLoads []string
 	programJob := &compileJob{
 		description:  "link+optimize packages (LTO)",
@@ -409,9 +494,9 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 			// Load and link all the bitcode files. This does not yet optimize
 			// anything, it only links the bitcode files together.
 			ctx := llvm.NewContext()
-			mod = ctx.NewModule("")
-			for _, pkg := range lprogram.Sorted() {
-				pkgMod, err := ctx.ParseBitcodeFile(packageBitcodePaths[pkg.ImportPath])
+			mod = ctx.NewModule("main")
+			for _, pkgJob := range packageJobs {
+				pkgMod, err := ctx.ParseBitcodeFile(pkgJob.result)
 				if err != nil {
 					return fmt.Errorf("failed to load bitcode file: %w", err)
 				}
@@ -503,13 +588,20 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 			if err != nil {
 				return err
 			}
-			return ioutil.WriteFile(outpath, llvmBuf.Bytes(), 0666)
+			defer llvmBuf.Dispose()
+			return os.WriteFile(outpath, llvmBuf.Bytes(), 0666)
 		case ".bc":
-			data := llvm.WriteBitcodeToMemoryBuffer(mod).Bytes()
-			return ioutil.WriteFile(outpath, data, 0666)
+			var buf llvm.MemoryBuffer
+			if config.UseThinLTO() {
+				buf = llvm.WriteThinLTOBitcodeToMemoryBuffer(mod)
+			} else {
+				buf = llvm.WriteBitcodeToMemoryBuffer(mod)
+			}
+			defer buf.Dispose()
+			return os.WriteFile(outpath, buf.Bytes(), 0666)
 		case ".ll":
 			data := []byte(mod.String())
-			return ioutil.WriteFile(outpath, data, 0666)
+			return os.WriteFile(outpath, data, 0666)
 		default:
 			panic("unreachable")
 		}
@@ -526,11 +618,18 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		dependencies: []*compileJob{programJob},
 		result:       objfile,
 		run: func(*compileJob) error {
-			llvmBuf, err := machine.EmitToMemoryBuffer(mod, llvm.ObjectFile)
-			if err != nil {
-				return err
+			var llvmBuf llvm.MemoryBuffer
+			if config.UseThinLTO() {
+				llvmBuf = llvm.WriteThinLTOBitcodeToMemoryBuffer(mod)
+			} else {
+				var err error
+				llvmBuf, err = machine.EmitToMemoryBuffer(mod, llvm.ObjectFile)
+				if err != nil {
+					return err
+				}
 			}
-			return ioutil.WriteFile(objfile, llvmBuf.Bytes(), 0666)
+			defer llvmBuf.Dispose()
+			return os.WriteFile(objfile, llvmBuf.Bytes(), 0666)
 		},
 	}

@@ -562,7 +661,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		job := &compileJob{
 			description: "compile extra file " + path,
 			run: func(job *compileJob) error {
-				result, err := compileAndCacheCFile(abspath, dir, config.CFlags(), config.Options.PrintCommands)
+				result, err := compileAndCacheCFile(abspath, dir, config.CFlags(), config.UseThinLTO(), config.Options.PrintCommands)
 				job.result = result
 				return err
 			},
@@ -580,7 +679,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 			job := &compileJob{
 				description: "compile CGo file " + abspath,
 				run: func(job *compileJob) error {
-					result, err := compileAndCacheCFile(abspath, dir, pkg.CFlags, config.Options.PrintCommands)
+					result, err := compileAndCacheCFile(abspath, dir, pkg.CFlags, config.UseThinLTO(), config.Options.PrintCommands)
 					job.result = result
 					return err
 				},
@@ -598,6 +697,9 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 	// Add libc dependencies, if they exist.
 	linkerDependencies = append(linkerDependencies, libcDependencies...)

+	// Add embedded files.
+	linkerDependencies = append(linkerDependencies, embedFileObjects...)
+
 	// Strip debug information with -no-debug.
 	if !config.Debug() {
 		for _, tag := range config.BuildTags() {
@@ -607,6 +709,12 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 				return fmt.Errorf("stripping debug information is unnecessary for baremetal targets")
 			}
 		}
+		if config.GOOS() == "darwin" {
+			// Debug information isn't stored in the binary itself on MacOS but
+			// is left in the object files by default. The binary does store the
+			// path to these object files though.
+			return errors.New("cannot remove debug information: MacOS doesn't store debug info in the executable by default")
+		}
 		if config.Target.Linker == "wasm-ld" {
 			// Don't just strip debug information, also compress relocations
 			// while we're at it. Relocations can only be compressed when debug
@@ -616,21 +724,8 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 			// ld.lld is also used on Linux.
 			ldflags = append(ldflags, "--strip-debug")
 		} else {
-			switch config.GOOS() {
-			case "linux":
-				// Either real linux or an embedded system (like AVR) that
-				// pretends to be Linux. It's a ELF linker wrapped by GCC in any
-				// case (not ld.lld - that case is handled above).
-				ldflags = append(ldflags, "-Wl,--strip-debug")
-			case "darwin":
-				// MacOS (darwin) doesn't have a linker flag to strip debug
-				// information. Apple expects you to use the strip command
-				// instead.
-				return errors.New("cannot remove debug information: MacOS doesn't suppor this linker flag")
-			default:
-				// Other OSes may have different flags.
-				return errors.New("cannot remove debug information: unknown OS: " + config.GOOS())
-			}
+			// Other linkers may have different flags.
+			return errors.New("cannot remove debug information: unknown linker: " + config.Target.Linker)
 		}
 	}

@@ -649,6 +744,37 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 			if config.Options.PrintCommands != nil {
 				config.Options.PrintCommands(config.Target.Linker, ldflags...)
 			}
+			if config.UseThinLTO() {
+				ldflags = append(ldflags, "-mllvm", "-mcpu="+config.CPU())
+				if config.GOOS() == "windows" {
+					// Options for the MinGW wrapper for the lld COFF linker.
+					ldflags = append(ldflags,
+						"-Xlink=/opt:lldlto="+strconv.Itoa(optLevel),
+						"--thinlto-cache-dir="+filepath.Join(cacheDir, "thinlto"))
+				} else if config.GOOS() == "darwin" {
+					// Options for the ld64-compatible lld linker.
+					ldflags = append(ldflags,
+						"--lto-O"+strconv.Itoa(optLevel),
+						"-cache_path_lto", filepath.Join(cacheDir, "thinlto"))
+				} else {
+					// Options for the ELF linker.
+					ldflags = append(ldflags,
+						"--lto-O"+strconv.Itoa(optLevel),
+						"--thinlto-cache-dir="+filepath.Join(cacheDir, "thinlto"),
+					)
+				}
+				if config.CodeModel() != "default" {
+					ldflags = append(ldflags,
+						"-mllvm", "-code-model="+config.CodeModel())
+				}
+				if sizeLevel >= 2 {
+					// Workaround with roughly the same effect as
+					// https://reviews.llvm.org/D119342.
+					// Can hopefully be removed in LLVM 15.
+					ldflags = append(ldflags,
+						"-mllvm", "--rotation-max-header-size=0")
+				}
+			}
 			err = link(config.Target.Linker, ldflags...)
 			if err != nil {
 				return &commandError{"failed to link", executable, err}
@@ -779,7 +905,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		if err != nil {
 			return err
 		}
-	case "esp32", "esp32c3", "esp8266":
+	case "esp32", "esp32-img", "esp32c3", "esp8266":
 		// Special format for the ESP family of chips (parsed by the ROM
 		// bootloader).
 		tmppath = filepath.Join(dir, "main"+outext)
@@ -811,6 +937,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 	}

 	return action(BuildResult{
+		Executable: executable,
 		Binary:     tmppath,
 		MainDir:    lprogram.MainPkg().Dir,
 		ModuleRoot: moduleroot,
@@ -818,11 +945,117 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 	})
 }

+// createEmbedObjectFile creates a new object file with the given contents, for
+// the embed package.
+func createEmbedObjectFile(data, hexSum, sourceFile, sourceDir, tmpdir string, compilerConfig *compiler.Config) (string, error) {
+	// TODO: this works for small files, but can be a problem for larger files.
+	// For larger files, it seems more appropriate to generate the object file
+	// manually without going through LLVM.
+	// On the other hand, generating DWARF like we do here can be difficult
+	// without assistance from LLVM.
+
+	// Create new LLVM module just for this file.
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	mod := ctx.NewModule("data")
+	defer mod.Dispose()
+
+	// Create data global.
+	value := ctx.ConstString(data, false)
+	globalName := "embed/file_" + hexSum
+	global := llvm.AddGlobal(mod, value.Type(), globalName)
+	global.SetInitializer(value)
+	global.SetLinkage(llvm.LinkOnceODRLinkage)
+	global.SetGlobalConstant(true)
+	global.SetUnnamedAddr(true)
+	global.SetAlignment(1)
+	if compilerConfig.GOOS != "darwin" {
+		// MachO doesn't support COMDATs, while COFF requires it (to avoid
+		// "duplicate symbol" errors). ELF works either way.
+		// Therefore, only use a COMDAT on non-MachO systems (aka non-MacOS).
+		global.SetComdat(mod.Comdat(globalName))
+	}
+
+	// Add DWARF debug information to this global, so that it is
+	// correctly counted when compiling with the -size= flag.
+	dibuilder := llvm.NewDIBuilder(mod)
+	dibuilder.CreateCompileUnit(llvm.DICompileUnit{
+		Language:  0xb, // DW_LANG_C99 (0xc, off-by-one?)
+		File:      sourceFile,
+		Dir:       sourceDir,
+		Producer:  "TinyGo",
+		Optimized: false,
+	})
+	ditype := dibuilder.CreateArrayType(llvm.DIArrayType{
+		SizeInBits:  uint64(len(data)) * 8,
+		AlignInBits: 8,
+		ElementType: dibuilder.CreateBasicType(llvm.DIBasicType{
+			Name:       "byte",
+			SizeInBits: 8,
+			Encoding:   llvm.DW_ATE_unsigned_char,
+		}),
+		Subscripts: []llvm.DISubrange{
+			{
+				Lo:    0,
+				Count: int64(len(data)),
+			},
+		},
+	})
+	difile := dibuilder.CreateFile(sourceFile, sourceDir)
+	diglobalexpr := dibuilder.CreateGlobalVariableExpression(difile, llvm.DIGlobalVariableExpression{
+		Name:        globalName,
+		File:        difile,
+		Line:        1,
+		Type:        ditype,
+		Expr:        dibuilder.CreateExpression(nil),
+		AlignInBits: 8,
+	})
+	global.AddMetadata(0, diglobalexpr)
+	mod.AddNamedMetadataOperand("llvm.module.flags",
+		ctx.MDNode([]llvm.Metadata{
+			llvm.ConstInt(ctx.Int32Type(), 2, false).ConstantAsMetadata(), // Warning on mismatch
+			ctx.MDString("Debug Info Version"),
+			llvm.ConstInt(ctx.Int32Type(), 3, false).ConstantAsMetadata(),
+		}),
+	)
+	mod.AddNamedMetadataOperand("llvm.module.flags",
+		ctx.MDNode([]llvm.Metadata{
+			llvm.ConstInt(ctx.Int32Type(), 7, false).ConstantAsMetadata(), // Max on mismatch
+			ctx.MDString("Dwarf Version"),
+			llvm.ConstInt(ctx.Int32Type(), 4, false).ConstantAsMetadata(),
+		}),
+	)
+	dibuilder.Finalize()
+	dibuilder.Destroy()
+
+	// Write this LLVM module out as an object file.
+	machine, err := compiler.NewTargetMachine(compilerConfig)
+	if err != nil {
+		return "", err
+	}
+	defer machine.Dispose()
+	outfile, err := os.CreateTemp(tmpdir, "embed-"+hexSum+"-*.o")
+	if err != nil {
+		return "", err
+	}
+	defer outfile.Close()
+	buf, err := machine.EmitToMemoryBuffer(mod, llvm.ObjectFile)
+	if err != nil {
+		return "", err
+	}
+	defer buf.Dispose()
+	_, err = outfile.Write(buf.Bytes())
+	if err != nil {
+		return "", err
+	}
+	return outfile.Name(), outfile.Close()
+}
+
 // optimizeProgram runs a series of optimizations and transformations that are
 // needed to convert a program to its final form. Some transformations are not
 // optional and must be run as the compiler expects them to run.
 func optimizeProgram(mod llvm.Module, config *compileopts.Config) error {
-	err := interp.Run(mod, config.DumpSSA())
+	err := interp.Run(mod, config.Options.InterpTimeout, config.DumpSSA())
 	if err != nil {
 		return err
 	}
@@ -839,7 +1072,7 @@ func optimizeProgram(mod llvm.Module, config *compileopts.Config) error {
 		}
 	}

-	if config.GOOS() != "darwin" {
+	if config.GOOS() != "darwin" && !config.UseThinLTO() {
 		transform.ApplyFunctionSections(mod) // -ffunction-sections
 	}

@@ -872,17 +1105,6 @@ func optimizeProgram(mod llvm.Module, config *compileopts.Config) error {
 		return errors.New("verification failure after LLVM optimization passes")
 	}

-	// LLVM 11 by default tries to emit tail calls (even with the target feature
-	// disabled) unless it is explicitly disabled with a function attribute.
-	// This is a problem, as it tries to emit them and prints an error when it
-	// can't with this feature disabled.
-	// Because as of september 2020 tail calls are not yet widely supported,
-	// they need to be disabled until they are widely supported (at which point
-	// the +tail-call target feautre can be set).
-	if strings.HasPrefix(config.Triple(), "wasm") {
-		transform.DisableTailCalls(mod)
-	}
-
 	return nil
 }

@@ -1145,10 +1367,10 @@ func modifyStackSizes(executable string, stackSizeLoads []string, stackSizes map
 //
 // It might print something like the following:
 //
-//     function                         stack usage (in bytes)
-//     Reset_Handler                    316
-//     examples/blinky2.led1            92
-//     runtime.run$1                    300
+//	function                         stack usage (in bytes)
+//	Reset_Handler                    316
+//	examples/blinky2.led1            92
+//	runtime.run$1                    300
 func printStacks(calculatedStacks []string, stackSizes map[string]functionStackSize) {
 	// Print the sizes of all stacks.
 	fmt.Printf("%-32s %s\n", "function", "stack usage (in bytes)")
@@ -2,7 +2,6 @@ package builder

 import (
 	"fmt"
-	"io/ioutil"
 	"os"
 	"path/filepath"
 	"runtime"
@@ -26,7 +25,7 @@ func TestClangAttributes(t *testing.T) {
 		"cortex-m0",
 		"cortex-m0plus",
 		"cortex-m3",
-		//"cortex-m33", // TODO: broken in LLVM 11, fixed in https://reviews.llvm.org/D90305
+		"cortex-m33",
 		"cortex-m4",
 		"cortex-m7",
 		"esp32c3",
@@ -90,7 +89,7 @@ func testClangAttributes(t *testing.T, options *compileopts.Options) {

 	// Create a very simple C input file.
 	srcpath := filepath.Join(testDir, "test.c")
-	err = ioutil.WriteFile(srcpath, []byte("int add(int a, int b) { return a + b; }"), 0o666)
+	err = os.WriteFile(srcpath, []byte("int add(int a, int b) { return a + b; }"), 0o666)
 	if err != nil {
 		t.Fatalf("could not write target file %s: %s", srcpath, err)
 	}
@@ -24,7 +24,7 @@ func ReadBuildID() ([]byte, error) {
 	defer f.Close()

 	switch runtime.GOOS {
-	case "linux", "freebsd":
+	case "linux", "freebsd", "android":
 		// Read the GNU build id section. (Not sure about FreeBSD though...)
 		file, err := elf.NewFile(f)
 		if err != nil {
@@ -1,7 +1,11 @@
 package builder

 import (
+	"os"
+	"path/filepath"
 	"strings"
+
+	"github.com/tinygo-org/tinygo/goenv"
 )

 // These are the GENERIC_SOURCES according to CMakeList.txt.
@@ -36,7 +40,6 @@ var genericBuiltins = []string{
 	"divdf3.c",
 	"divdi3.c",
 	"divmoddi4.c",
-	"divmodsi4.c",
 	"divsc3.c",
 	"divsf3.c",
 	"divsi3.c",
@@ -72,6 +75,7 @@ var genericBuiltins = []string{
 	"floatunsisf.c",
 	"floatuntidf.c",
 	"floatuntisf.c",
+	"fp_mode.c",
 	//"int_util.c",
 	"lshrdi3.c",
 	"lshrti3.c",
@@ -122,7 +126,6 @@ var genericBuiltins = []string{
 	"ucmpti2.c",
 	"udivdi3.c",
 	"udivmoddi4.c",
-	"udivmodsi4.c",
 	"udivmodti4.c",
 	"udivsi3.c",
 	"udivti3.c",
@@ -149,6 +152,14 @@ var aeabiBuiltins = []string{
 	"arm/aeabi_memset.S",
 	"arm/aeabi_uidivmod.S",
 	"arm/aeabi_uldivmod.S",
+
+	// These two are not technically EABI builtins but are used by them and only
+	// seem to be used on ARM. LLVM seems to use __divsi3 and __modsi3 on most
+	// other architectures.
+	// Most importantly, they have a different calling convention on AVR so
+	// should not be used on AVR.
+	"divmodsi4.c",
+	"udivmodsi4.c",
 }

 // CompilerRT is a library with symbols required by programs compiled with LLVM.
@@ -161,7 +172,15 @@ var CompilerRT = Library{
 	cflags: func(target, headerPath string) []string {
 		return []string{"-Werror", "-Wall", "-std=c11", "-nostdlibinc"}
 	},
-	sourceDir: "lib/compiler-rt/lib/builtins",
+	sourceDir: func() string {
+		llvmDir := filepath.Join(goenv.Get("TINYGOROOT"), "llvm-project/compiler-rt/lib/builtins")
+		if _, err := os.Stat(llvmDir); err == nil {
+			// Release build.
+			return llvmDir
+		}
+		// Development build.
+		return filepath.Join(goenv.Get("TINYGOROOT"), "lib/compiler-rt-builtins")
+	},
 	librarySources: func(target string) []string {
 		builtins := append([]string{}, genericBuiltins...) // copy genericBuiltins
 		if strings.HasPrefix(target, "arm") || strings.HasPrefix(target, "thumb") {
@@ -10,7 +10,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"io/ioutil"
+	"io/fs"
 	"os"
 	"path/filepath"
 	"sort"
@@ -33,30 +33,30 @@ import (
 // Because of this complexity, every file has in fact two cached build outputs:
 // the file itself, and the list of dependencies. Its operation is as follows:
 //
-//   depfile = hash(path, compiler, cflags, ...)
-//   if depfile exists:
-//     outfile = hash of all files and depfile name
-//     if outfile exists:
-//       # cache hit
-//       return outfile
-//   # cache miss
-//   tmpfile = compile file
-//   read dependencies (side effect of compile)
-//   write depfile
-//   outfile = hash of all files and depfile name
-//   rename tmpfile to outfile
+//	depfile = hash(path, compiler, cflags, ...)
+//	if depfile exists:
+//	  outfile = hash of all files and depfile name
+//	  if outfile exists:
+//	    # cache hit
+//	    return outfile
+//	# cache miss
+//	tmpfile = compile file
+//	read dependencies (side effect of compile)
+//	write depfile
+//	outfile = hash of all files and depfile name
+//	rename tmpfile to outfile
 //
 // There are a few edge cases that are not handled:
-// - If a file is added to an include path, that file may be included instead of
-//   some other file. This would be fixed by also including lookup failures in the
-//   dependencies file, but I'm not aware of a compiler which does that.
-// - The Makefile syntax that compilers output has issues, see readDepFile for
-//   details.
-// - A header file may be changed to add/remove an include. This invalidates the
-//   depfile but without invalidating its name. For this reason, the depfile is
-//   written on each new compilation (even when it seems unnecessary). However, it
-//   could in rare cases lead to a stale file fetched from the cache.
-func compileAndCacheCFile(abspath, tmpdir string, cflags []string, printCommands func(string, ...string)) (string, error) {
+//   - If a file is added to an include path, that file may be included instead of
+//     some other file. This would be fixed by also including lookup failures in the
+//     dependencies file, but I'm not aware of a compiler which does that.
+//   - The Makefile syntax that compilers output has issues, see readDepFile for
+//     details.
+//   - A header file may be changed to add/remove an include. This invalidates the
+//     depfile but without invalidating its name. For this reason, the depfile is
+//     written on each new compilation (even when it seems unnecessary). However, it
+//     could in rare cases lead to a stale file fetched from the cache.
+func compileAndCacheCFile(abspath, tmpdir string, cflags []string, thinlto bool, printCommands func(string, ...string)) (string, error) {
 	// Hash input file.
 	fileHash, err := hashFile(abspath)
 	if err != nil {
@@ -67,6 +67,11 @@ func compileAndCacheCFile(abspath, tmpdir string, cflags []string, printCommands
 	unlock := lock(filepath.Join(goenv.Get("GOCACHE"), fileHash+".c.lock"))
 	defer unlock()

+	ext := ".o"
+	if thinlto {
+		ext = ".bc"
+	}
+
 	// Create cache key for the dependencies file.
 	buf, err := json.Marshal(struct {
 		Path        string
@@ -88,7 +93,7 @@ func compileAndCacheCFile(abspath, tmpdir string, cflags []string, printCommands
 	// Load dependencies file, if possible.
 	depfileName := "dep-" + depfileNameHash + ".json"
 	depfileCachePath := filepath.Join(goenv.Get("GOCACHE"), depfileName)
-	depfileBuf, err := ioutil.ReadFile(depfileCachePath)
+	depfileBuf, err := os.ReadFile(depfileCachePath)
 	var dependencies []string // sorted list of dependency paths
 	if err == nil {
 		// There is a dependency file, that's great!
@@ -99,31 +104,34 @@ func compileAndCacheCFile(abspath, tmpdir string, cflags []string, printCommands
 		}

 		// Obtain hashes of all the files listed as a dependency.
-		outpath, err := makeCFileCachePath(dependencies, depfileNameHash)
+		outpath, err := makeCFileCachePath(dependencies, depfileNameHash, ext)
 		if err == nil {
 			if _, err := os.Stat(outpath); err == nil {
 				return outpath, nil
-			} else if !os.IsNotExist(err) {
+			} else if !errors.Is(err, fs.ErrNotExist) {
 				return "", err
 			}
 		}
-	} else if !os.IsNotExist(err) {
+	} else if !errors.Is(err, fs.ErrNotExist) {
 		// expected either nil or IsNotExist
 		return "", err
 	}

-	objTmpFile, err := ioutil.TempFile(goenv.Get("GOCACHE"), "tmp-*.o")
+	objTmpFile, err := os.CreateTemp(goenv.Get("GOCACHE"), "tmp-*"+ext)
 	if err != nil {
 		return "", err
 	}
 	objTmpFile.Close()
-	depTmpFile, err := ioutil.TempFile(tmpdir, "dep-*.d")
+	depTmpFile, err := os.CreateTemp(tmpdir, "dep-*.d")
 	if err != nil {
 		return "", err
 	}
 	depTmpFile.Close()
 	flags := append([]string{}, cflags...)                                   // copy cflags
 	flags = append(flags, "-MD", "-MV", "-MTdeps", "-MF", depTmpFile.Name()) // autogenerate dependencies
+	if thinlto {
+		flags = append(flags, "-flto=thin")
+	}
 	flags = append(flags, "-c", "-o", objTmpFile.Name(), abspath)
 	if strings.ToLower(filepath.Ext(abspath)) == ".s" {
 		// If this is an assembly file (.s or .S, lowercase or uppercase), then
@@ -158,7 +166,7 @@ func compileAndCacheCFile(abspath, tmpdir string, cflags []string, printCommands
 	sort.Strings(dependencySlice)

 	// Write dependencies file.
-	f, err := ioutil.TempFile(filepath.Dir(depfileCachePath), depfileName)
+	f, err := os.CreateTemp(filepath.Dir(depfileCachePath), depfileName)
 	if err != nil {
 		return "", err
 	}
@@ -181,7 +189,7 @@ func compileAndCacheCFile(abspath, tmpdir string, cflags []string, printCommands
 	}

 	// Move temporary object file to final location.
-	outpath, err := makeCFileCachePath(dependencySlice, depfileNameHash)
+	outpath, err := makeCFileCachePath(dependencySlice, depfileNameHash, ext)
 	if err != nil {
 		return "", err
 	}
@@ -196,7 +204,7 @@ func compileAndCacheCFile(abspath, tmpdir string, cflags []string, printCommands
 // Create a cache path (a path in GOCACHE) to store the output of a compiler
 // job. This path is based on the dep file name (which is a hash of metadata
 // including compiler flags) and the hash of all input files in the paths slice.
-func makeCFileCachePath(paths []string, depfileNameHash string) (string, error) {
+func makeCFileCachePath(paths []string, depfileNameHash, ext string) (string, error) {
 	// Hash all input files.
 	fileHashes := make(map[string]string, len(paths))
 	for _, path := range paths {
@@ -221,7 +229,7 @@ func makeCFileCachePath(paths []string, depfileNameHash string) (string, error)
 	outFileNameBuf := sha512.Sum512_224(buf)
 	cacheKey := hex.EncodeToString(outFileNameBuf[:])

-	outpath := filepath.Join(goenv.Get("GOCACHE"), "obj-"+cacheKey+".o")
+	outpath := filepath.Join(goenv.Get("GOCACHE"), "obj-"+cacheKey+ext)
 	return outpath, nil
 }

@@ -244,13 +252,14 @@ func hashFile(path string) (string, error) {
 // file is assumed to have a single target named deps.
 //
 // There are roughly three make syntax variants:
-// - BSD make, which doesn't support any escaping. This means that many special
-//   characters are not supported in file names.
-// - GNU make, which supports escaping using a backslash but when it fails to
-//   find a file it tries to fall back with the literal path name (to match BSD
-//   make).
-// - NMake (Visual Studio) and Jom, which simply quote the string if there are
-//   any weird characters.
+//   - BSD make, which doesn't support any escaping. This means that many special
+//     characters are not supported in file names.
+//   - GNU make, which supports escaping using a backslash but when it fails to
+//     find a file it tries to fall back with the literal path name (to match BSD
+//     make).
+//   - NMake (Visual Studio) and Jom, which simply quote the string if there are
+//     any weird characters.
+//
 // Clang supports two variants: a format that's a compromise between BSD and GNU
 // make (and is buggy to match GCC which is equally buggy), and NMake/Jom, which
 // is at least somewhat sane. This last format isn't perfect either: it does not
@@ -258,7 +267,7 @@ func hashFile(path string) (string, error) {
 // allowed on Windows, but of course can be used on POSIX like systems. Still,
 // it's the most sane of any of the formats so readDepFile will use that format.
 func readDepFile(filename string) ([]string, error) {
-	buf, err := ioutil.ReadFile(filename)
+	buf, err := os.ReadFile(filename)
 	if err != nil {
 		return nil, err
 	}
@@ -38,6 +38,7 @@
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCTargetOptions.h"
+#include "llvm/MC/TargetRegistry.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/OptTable.h"
@@ -51,7 +52,6 @@
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/SourceMgr.h"
-#include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/Support/raw_ostream.h"
@@ -120,7 +120,6 @@ bool AssemblerInvocation::CreateFromArgs(AssemblerInvocation &Opts,
        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);
  }

@@ -382,7 +381,7 @@ static bool ExecuteAssemblerImpl(AssemblerInvocation &Opts,
        T, Ctx, std::move(MAB), std::move(OW), std::move(CE), *STI,
        Opts.RelaxAll, Opts.IncrementalLinkerCompatible,
        /*DWARFMustBeAtTheEnd*/ true));
-    Str.get()->InitSections(Opts.NoExecStack);
+    Str.get()->initSections(Opts.NoExecStack, *STI);
  }

  // When -fembed-bitcode is passed to clang_as, a 1-byte marker
@@ -442,7 +441,7 @@ bool ExecuteAssembler(AssemblerInvocation &Opts,
  return Failed;
 }

-static void LLVMErrorHandler(void *UserData, const std::string &Message,
+static void LLVMErrorHandler(void *UserData, const char *Message,
                             bool GenCrashDiag) {
  DiagnosticsEngine &Diags = *static_cast<DiagnosticsEngine*>(UserData);

@@ -74,7 +74,7 @@ func LookupCommand(name string) (string, error) {
 		}
 		return cmdName, nil
 	}
-	return "", errors.New("%#v: none of these commands were found in your $PATH: " + strings.Join(commands[name], " "))
+	return "", errors.New("none of these commands were found in your $PATH: " + strings.Join(commands[name], " "))
 }

 func execCommand(name string, args ...string) error {
@@ -33,8 +33,8 @@ func NewConfig(options *compileopts.Options) (*compileopts.Config, error) {
 	if err != nil {
 		return nil, fmt.Errorf("could not read version from GOROOT (%v): %v", goroot, err)
 	}
-	if major != 1 || minor < 15 || minor > 17 {
-		return nil, fmt.Errorf("requires go version 1.15 through 1.17, got go%d.%d", major, minor)
+	if major != 1 || minor < 18 || minor > 19 {
+		return nil, fmt.Errorf("requires go version 1.18 through 1.19, got go%d.%d", major, minor)
 	}

 	clangHeaderPath := getClangHeaderPath(goenv.Get("TINYGOROOT"))
@@ -0,0 +1,58 @@
+package builder
+
+import (
+	"path/filepath"
+	"strings"
+
+	"github.com/tinygo-org/tinygo/compileopts"
+	"github.com/tinygo-org/tinygo/goenv"
+)
+
+// Create a job that builds a Darwin libSystem.dylib stub library. This library
+// contains all the symbols needed so that we can link against it, but it
+// doesn't contain any real symbol implementations.
+func makeDarwinLibSystemJob(config *compileopts.Config, tmpdir string) *compileJob {
+	return &compileJob{
+		description: "compile Darwin libSystem.dylib",
+		run: func(job *compileJob) (err error) {
+			arch := strings.Split(config.Triple(), "-")[0]
+			job.result = filepath.Join(tmpdir, "libSystem.dylib")
+			objpath := filepath.Join(tmpdir, "libSystem.o")
+			inpath := filepath.Join(goenv.Get("TINYGOROOT"), "lib/macos-minimal-sdk/src", arch, "libSystem.s")
+
+			// Compile assembly file to object file.
+			flags := []string{
+				"-nostdlib",
+				"--target=" + config.Triple(),
+				"-c",
+				"-o", objpath,
+				inpath,
+			}
+			if config.Options.PrintCommands != nil {
+				config.Options.PrintCommands("clang", flags...)
+			}
+			err = runCCompiler(flags...)
+			if err != nil {
+				return err
+			}
+
+			// Link object file to dynamic library.
+			platformVersion := strings.TrimPrefix(strings.Split(config.Triple(), "-")[2], "macosx")
+			flags = []string{
+				"-flavor", "darwin",
+				"-demangle",
+				"-dynamic",
+				"-dylib",
+				"-arch", arch,
+				"-platform_version", "macos", platformVersion, platformVersion,
+				"-install_name", "/usr/lib/libSystem.B.dylib",
+				"-o", job.result,
+				objpath,
+			}
+			if config.Options.PrintCommands != nil {
+				config.Options.PrintCommands("ld.lld", flags...)
+			}
+			return link("ld.lld", flags...)
+		},
+	}
+}
@@ -1,6 +1,8 @@
 package builder

 import (
+	"errors"
+	"io/fs"
 	"io/ioutil"
 	"os"
 	"os/exec"
@@ -17,13 +19,13 @@ import (
 func getClangHeaderPath(TINYGOROOT string) string {
 	// Check whether we're running from the source directory.
 	path := filepath.Join(TINYGOROOT, "llvm-project", "clang", "lib", "Headers")
-	if _, err := os.Stat(path); !os.IsNotExist(err) {
+	if _, err := os.Stat(path); !errors.Is(err, fs.ErrNotExist) {
 		return path
 	}

 	// Check whether we're running from the installation directory.
 	path = filepath.Join(TINYGOROOT, "lib", "clang", "include")
-	if _, err := os.Stat(path); !os.IsNotExist(err) {
+	if _, err := os.Stat(path); !errors.Is(err, fs.ErrNotExist) {
 		return path
 	}

@@ -13,8 +13,9 @@ import (
 	"debug/elf"
 	"encoding/binary"
 	"fmt"
-	"io/ioutil"
+	"os"
 	"sort"
+	"strings"
 )

 type espImageSegment struct {
@@ -78,15 +79,31 @@ func makeESPFirmareImage(infile, outfile, format string) error {
 	// An added benefit is that we don't need to check for errors all the time.
 	outf := &bytes.Buffer{}

+	// Separate esp32 and esp32-img. The -img suffix indicates we should make an
+	// image, not just a binary to be flashed at 0x1000 for example.
+	chip := format
+	makeImage := false
+	if strings.HasSuffix(format, "-img") {
+		makeImage = true
+		chip = format[:len(format)-len("-img")]
+	}
+
+	if makeImage {
+		// The bootloader starts at 0x1000, or 4096.
+		// TinyGo doesn't use a separate bootloader and runs the entire
+		// application in the bootloader location.
+		outf.Write(make([]byte, 4096))
+	}
+
 	// Chip IDs. Source:
 	// https://github.com/espressif/esp-idf/blob/v4.3/components/bootloader_support/include/esp_app_format.h#L22
 	chip_id := map[string]uint16{
 		"esp32":   0x0000,
 		"esp32c3": 0x0005,
-	}[format]
+	}[chip]

 	// Image header.
-	switch format {
+	switch chip {
 	case "esp32", "esp32c3":
 		// Header format:
 		// https://github.com/espressif/esp-idf/blob/v4.3/components/bootloader_support/include/esp_app_format.h#L71
@@ -155,12 +172,22 @@ func makeESPFirmareImage(infile, outfile, format string) error {
 	outf.Write(make([]byte, 15-outf.Len()%16))
 	outf.WriteByte(checksum)

-	if format != "esp8266" {
+	if chip != "esp8266" {
 		// SHA256 hash (to protect against image corruption, not for security).
 		hash := sha256.Sum256(outf.Bytes())
 		outf.Write(hash[:])
 	}

+	// QEMU (or more precisely, qemu-system-xtensa from Espressif) expects the
+	// image to be a certain size.
+	if makeImage {
+		// Use a default image size of 4MB.
+		grow := 4096*1024 - outf.Len()
+		if grow > 0 {
+			outf.Write(make([]byte, grow))
+		}
+	}
+
 	// Write the image to the output file.
-	return ioutil.WriteFile(outfile, outf.Bytes(), 0666)
+	return os.WriteFile(outfile, outf.Bytes(), 0666)
 }
@@ -1,7 +1,8 @@
 package builder

 import (
-	"io/ioutil"
+	"errors"
+	"io/fs"
 	"os"
 	"path/filepath"
 	"runtime"
@@ -24,8 +25,8 @@ type Library struct {
 	// cflags returns the C flags specific to this library
 	cflags func(target, headerPath string) []string

-	// The source directory, relative to TINYGOROOT.
-	sourceDir string
+	// The source directory.
+	sourceDir func() string

 	// The source files, relative to sourceDir.
 	librarySources func(target string) []string
@@ -94,7 +95,7 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 	target := config.Triple()
 	if l.makeHeaders != nil {
 		if _, err = os.Stat(headerPath); err != nil {
-			temporaryHeaderPath, err := ioutil.TempDir(outdir, "include.tmp*")
+			temporaryHeaderPath, err := os.MkdirTemp(outdir, "include.tmp*")
 			if err != nil {
 				return nil, nil, err
 			}
@@ -103,13 +104,17 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 			if err != nil {
 				return nil, nil, err
 			}
+			err = os.Chmod(temporaryHeaderPath, 0o755) // TempDir uses 0o700 by default
+			if err != nil {
+				return nil, nil, err
+			}
 			err = os.Rename(temporaryHeaderPath, headerPath)
 			if err != nil {
 				switch {
-				case os.IsExist(err):
+				case errors.Is(err, fs.ErrExist):
 					// Another invocation of TinyGo also seems to have already created the headers.

-				case runtime.GOOS == "windows" && os.IsPermission(err):
+				case runtime.GOOS == "windows" && errors.Is(err, fs.ErrPermission):
 					// 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
@@ -144,12 +149,25 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 		// However, ARM has not done this.
 		if strings.HasPrefix(target, "i386") || strings.HasPrefix(target, "x86_64") {
 			args = append(args, "-march="+cpu)
+		} else if strings.HasPrefix(target, "avr") {
+			args = append(args, "-mmcu="+cpu)
 		} else {
 			args = append(args, "-mcpu="+cpu)
 		}
 	}
 	if strings.HasPrefix(target, "arm") || strings.HasPrefix(target, "thumb") {
-		args = append(args, "-fshort-enums", "-fomit-frame-pointer", "-mfloat-abi=soft", "-fno-unwind-tables")
+		if strings.Split(target, "-")[2] == "linux" {
+			args = append(args, "-fno-unwind-tables", "-fno-asynchronous-unwind-tables")
+		} else {
+			args = append(args, "-fshort-enums", "-fomit-frame-pointer", "-mfloat-abi=soft", "-fno-unwind-tables", "-fno-asynchronous-unwind-tables")
+		}
+	}
+	if strings.HasPrefix(target, "avr") {
+		// AVR defaults to C float and double both being 32-bit. This deviates
+		// from what most code (and certainly compiler-rt) expects. So we need
+		// to force the compiler to use 64-bit floating point numbers for
+		// double.
+		args = append(args, "-mdouble=64")
 	}
 	if strings.HasPrefix(target, "riscv32-") {
 		args = append(args, "-march=rv32imac", "-mabi=ilp32", "-fforce-enable-int128")
@@ -157,6 +175,12 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 	if strings.HasPrefix(target, "riscv64-") {
 		args = append(args, "-march=rv64gc", "-mabi=lp64")
 	}
+	if strings.HasPrefix(target, "xtensa") {
+		// Hack to work around an issue in the Xtensa port:
+		// https://github.com/espressif/llvm-project/issues/52
+		// Hopefully this will be fixed soon (LLVM 14).
+		args = append(args, "-D__ELF__")
+	}

 	var once sync.Once

@@ -170,7 +194,7 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 			defer once.Do(unlock)

 			// Create an archive of all object files.
-			f, err := ioutil.TempFile(outdir, "libc.a.tmp*")
+			f, err := os.CreateTemp(outdir, "libc.a.tmp*")
 			if err != nil {
 				return err
 			}
@@ -182,11 +206,17 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 			if err != nil {
 				return err
 			}
+			err = os.Chmod(f.Name(), 0o644) // TempFile uses 0o600 by default
+			if err != nil {
+				return err
+			}
 			// Store this archive in the cache.
 			return os.Rename(f.Name(), archiveFilePath)
 		},
 	}

+	sourceDir := l.sourceDir()
+
 	// Create jobs to compile all sources. These jobs are depended upon by the
 	// archive job above, so must be run first.
 	for _, path := range l.librarySources(target) {
@@ -195,7 +225,7 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 		for strings.HasPrefix(cleanpath, "../") {
 			cleanpath = cleanpath[3:]
 		}
-		srcpath := filepath.Join(goenv.Get("TINYGOROOT"), l.sourceDir, path)
+		srcpath := filepath.Join(sourceDir, path)
 		objpath := filepath.Join(dir, cleanpath+".o")
 		os.MkdirAll(filepath.Dir(objpath), 0o777)
 		objs = append(objs, objpath)
@@ -219,13 +249,13 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 	// (It could be done in parallel with creating the ar file, but it probably
 	// won't make much of a difference in speed).
 	if l.crt1Source != "" {
-		srcpath := filepath.Join(goenv.Get("TINYGOROOT"), l.sourceDir, l.crt1Source)
+		srcpath := filepath.Join(sourceDir, l.crt1Source)
 		job.dependencies = append(job.dependencies, &compileJob{
 			description: "compile " + srcpath,
 			run: func(*compileJob) error {
 				var compileArgs []string
 				compileArgs = append(compileArgs, args...)
-				tmpfile, err := ioutil.TempFile(outdir, "crt1.o.tmp*")
+				tmpfile, err := os.CreateTemp(outdir, "crt1.o.tmp*")
 				if err != nil {
 					return err
 				}
@@ -8,17 +8,22 @@ extern "C" {

 bool tinygo_link_elf(int argc, char **argv) {
 	std::vector<const char*> args(argv, argv + argc);
-	return lld::elf::link(args, false, llvm::outs(), llvm::errs());
+	return lld::elf::link(args, llvm::outs(), llvm::errs(), false, false);
+}
+
+bool tinygo_link_macho(int argc, char **argv) {
+	std::vector<const char*> args(argv, argv + argc);
+	return lld::macho::link(args, llvm::outs(), llvm::errs(), false, false);
 }

 bool tinygo_link_mingw(int argc, char **argv) {
 	std::vector<const char*> args(argv, argv + argc);
-	return lld::mingw::link(args, false, llvm::outs(), llvm::errs());
+	return lld::mingw::link(args, llvm::outs(), llvm::errs(), false, false);
 }

 bool tinygo_link_wasm(int argc, char **argv) {
 	std::vector<const char*> args(argv, argv + argc);
-	return lld::wasm::link(args, false, llvm::outs(), llvm::errs());
+	return lld::wasm::link(args, llvm::outs(), llvm::errs(), false, false);
 }

 } // external "C"
@@ -26,6 +26,7 @@ var MinGW = Library{
 		_, err = io.Copy(outf, inf)
 		return err
 	},
+	sourceDir: func() string { return "" }, // unused
 	cflags: func(target, headerPath string) []string {
 		// No flags necessary because there are no files to compile.
 		return nil
@@ -77,7 +78,7 @@ func makeMinGWExtraLibs(tmpdir string) []*compileJob {
 					// .in files need to be preprocessed by a preprocessor (-E)
 					// first.
 					defpath = outpath + ".def"
-					err := runCCompiler("-E", "-x", "c", "-Wp,-w", "-P", "-DDEF_X64", "-o", defpath, inpath, "-I"+goenv.Get("TINYGOROOT")+"/lib/mingw-w64/mingw-w64-crt/def-include/")
+					err := runCCompiler("-E", "-x", "c", "-Wp,-w", "-P", "-DDEF_X64", "-DDATA", "-o", defpath, inpath, "-I"+goenv.Get("TINYGOROOT")+"/lib/mingw-w64/mingw-w64-crt/def-include/")
 					if err != nil {
 						return err
 					}
@@ -3,7 +3,6 @@ package builder
 import (
 	"bytes"
 	"fmt"
-	"io/ioutil"
 	"os"
 	"path/filepath"
 	"regexp"
@@ -35,7 +34,7 @@ var Musl = Library{
 			filepath.Join(muslDir, "include", "alltypes.h.in"),
 		}
 		for _, infile := range infiles {
-			data, err := ioutil.ReadFile(infile)
+			data, err := os.ReadFile(infile)
 			if err != nil {
 				return err
 			}
@@ -63,7 +62,7 @@ var Musl = Library{
 		if err != nil {
 			return err
 		}
-		data, err := ioutil.ReadFile(filepath.Join(muslDir, "arch", arch, "bits", "syscall.h.in"))
+		data, err := os.ReadFile(filepath.Join(muslDir, "arch", arch, "bits", "syscall.h.in"))
 		if err != nil {
 			return err
 		}
@@ -90,6 +89,7 @@ var Musl = Library{
 			"-Wno-shift-op-parentheses",
 			"-Wno-ignored-attributes",
 			"-Wno-string-plus-int",
+			"-Wno-ignored-pragmas",
 			"-Qunused-arguments",
 			// Select include dirs. Don't include standard library includes
 			// (that would introduce host dependencies and other complications),
@@ -104,7 +104,7 @@ var Musl = Library{
 			"-fno-stack-protector",
 		}
 	},
-	sourceDir: "lib/musl/src",
+	sourceDir: func() string { return filepath.Join(goenv.Get("TINYGOROOT"), "lib/musl/src") },
 	librarySources: func(target string) []string {
 		arch := compileopts.MuslArchitecture(target)
 		globs := []string{
@@ -115,8 +115,10 @@ var Musl = Library{
 			"internal/libc.c",
 			"internal/syscall_ret.c",
 			"internal/vdso.c",
+			"legacy/*.c",
 			"malloc/*.c",
 			"mman/*.c",
+			"math/*.c",
 			"signal/*.c",
 			"stdio/*.c",
 			"string/*.c",
@@ -2,7 +2,7 @@ package builder

 import (
 	"fmt"
-	"io/ioutil"
+	"io"
 	"os/exec"

 	"github.com/tinygo-org/tinygo/compileopts"
@@ -18,7 +18,7 @@ func makeDFUFirmwareImage(options *compileopts.Options, infile, outfile string)
 	}

 	cmd := exec.Command(cmdLine[0], cmdLine[1:]...)
-	cmd.Stdout = ioutil.Discard
+	cmd.Stdout = io.Discard
 	err := cmd.Run()
 	if err != nil {
 		return fmt.Errorf("could not run nrfutil pkg generate: %w", err)
@@ -2,7 +2,7 @@ package builder

 import (
 	"debug/elf"
-	"io/ioutil"
+	"io"
 	"os"
 	"sort"

@@ -87,7 +87,7 @@ func extractROM(path string) (uint64, []byte, error) {
 			// Pad the difference
 			rom = append(rom, make([]byte, diff)...)
 		}
-		data, err := ioutil.ReadAll(prog.Open())
+		data, err := io.ReadAll(prog.Open())
 		if err != nil {
 			return 0, nil, objcopyError{"failed to extract segment from ELF file: " + path, err}
 		}
@@ -19,7 +19,7 @@ var Picolibc = Library{
 		return f.Close()
 	},
 	cflags: func(target, headerPath string) []string {
-		picolibcDir := filepath.Join(goenv.Get("TINYGOROOT"), "lib/picolibc/newlib/libc")
+		newlibDir := filepath.Join(goenv.Get("TINYGOROOT"), "lib/picolibc/newlib")
 		return []string{
 			"-Werror",
 			"-Wall",
@@ -27,219 +27,395 @@ var Picolibc = Library{
 			"-D_COMPILING_NEWLIB",
 			"-DHAVE_ALIAS_ATTRIBUTE",
 			"-DTINY_STDIO",
+			"-D_IEEE_LIBM",
+			"-D__OBSOLETE_MATH_FLOAT=1", // use old math code that doesn't expect a FPU
+			"-D__OBSOLETE_MATH_DOUBLE=0",
 			"-nostdlibinc",
-			"-isystem", picolibcDir + "/include",
-			"-I" + picolibcDir + "/tinystdio",
+			"-isystem", newlibDir + "/libc/include",
+			"-I" + newlibDir + "/libc/tinystdio",
+			"-I" + newlibDir + "/libm/common",
 			"-I" + headerPath,
 		}
 	},
-	sourceDir: "lib/picolibc/newlib/libc",
+	sourceDir: func() string { return filepath.Join(goenv.Get("TINYGOROOT"), "lib/picolibc/newlib") },
 	librarySources: func(target string) []string {
 		return picolibcSources
 	},
 }

 var picolibcSources = []string{
-	"../../../picolibc-stdio.c",
+	"../../picolibc-stdio.c",

-	"tinystdio/asprintf.c",
-	"tinystdio/atod_engine.c",
-	"tinystdio/atod_ryu.c",
-	"tinystdio/atof_engine.c",
-	"tinystdio/atof_ryu.c",
-	//"tinystdio/atold_engine.c", // have_long_double and not long_double_equals_double
-	"tinystdio/clearerr.c",
-	"tinystdio/compare_exchange.c",
-	"tinystdio/dtoa_data.c",
-	"tinystdio/dtoa_engine.c",
-	"tinystdio/dtoa_ryu.c",
-	"tinystdio/ecvtbuf.c",
-	"tinystdio/ecvt.c",
-	"tinystdio/ecvt_data.c",
-	"tinystdio/ecvtfbuf.c",
-	"tinystdio/ecvtf.c",
-	"tinystdio/ecvtf_data.c",
-	"tinystdio/exchange.c",
-	//"tinystdio/fclose.c", // posix-io
-	"tinystdio/fcvtbuf.c",
-	"tinystdio/fcvt.c",
-	"tinystdio/fcvtfbuf.c",
-	"tinystdio/fcvtf.c",
-	"tinystdio/fdevopen.c",
-	//"tinystdio/fdopen.c", // posix-io
-	"tinystdio/feof.c",
-	"tinystdio/ferror.c",
-	"tinystdio/fflush.c",
-	"tinystdio/fgetc.c",
-	"tinystdio/fgets.c",
-	"tinystdio/fileno.c",
-	"tinystdio/filestrget.c",
-	"tinystdio/filestrputalloc.c",
-	"tinystdio/filestrput.c",
-	//"tinystdio/fopen.c", // posix-io
-	"tinystdio/fprintf.c",
-	"tinystdio/fputc.c",
-	"tinystdio/fputs.c",
-	"tinystdio/fread.c",
-	"tinystdio/fscanf.c",
-	"tinystdio/fseek.c",
-	"tinystdio/ftell.c",
-	"tinystdio/ftoa_data.c",
-	"tinystdio/ftoa_engine.c",
-	"tinystdio/ftoa_ryu.c",
-	"tinystdio/fwrite.c",
-	"tinystdio/gcvtbuf.c",
-	"tinystdio/gcvt.c",
-	"tinystdio/gcvtfbuf.c",
-	"tinystdio/gcvtf.c",
-	"tinystdio/getchar.c",
-	"tinystdio/gets.c",
-	"tinystdio/matchcaseprefix.c",
-	"tinystdio/perror.c",
-	//"tinystdio/posixiob.c", // posix-io
-	//"tinystdio/posixio.c", // posix-io
-	"tinystdio/printf.c",
-	"tinystdio/putchar.c",
-	"tinystdio/puts.c",
-	"tinystdio/ryu_divpow2.c",
-	"tinystdio/ryu_log10.c",
-	"tinystdio/ryu_log2pow5.c",
-	"tinystdio/ryu_pow5bits.c",
-	"tinystdio/ryu_table.c",
-	"tinystdio/ryu_umul128.c",
-	"tinystdio/scanf.c",
-	"tinystdio/setbuf.c",
-	"tinystdio/setvbuf.c",
-	//"tinystdio/sflags.c", // posix-io
-	"tinystdio/snprintf.c",
-	"tinystdio/snprintfd.c",
-	"tinystdio/snprintff.c",
-	"tinystdio/sprintf.c",
-	"tinystdio/sprintfd.c",
-	"tinystdio/sprintff.c",
-	"tinystdio/sscanf.c",
-	"tinystdio/strfromd.c",
-	"tinystdio/strfromf.c",
-	"tinystdio/strtod.c",
-	"tinystdio/strtod_l.c",
-	"tinystdio/strtof.c",
-	//"tinystdio/strtold.c",   // have_long_double and not long_double_equals_double
-	//"tinystdio/strtold_l.c", // have_long_double and not long_double_equals_double
-	"tinystdio/ungetc.c",
-	"tinystdio/vasprintf.c",
-	"tinystdio/vfiprintf.c",
-	"tinystdio/vfiscanf.c",
-	"tinystdio/vfprintf.c",
-	"tinystdio/vfprintff.c",
-	"tinystdio/vfscanf.c",
-	"tinystdio/vfscanff.c",
-	"tinystdio/vprintf.c",
-	"tinystdio/vscanf.c",
-	"tinystdio/vsnprintf.c",
-	"tinystdio/vsprintf.c",
-	"tinystdio/vsscanf.c",
+	"libc/tinystdio/asprintf.c",
+	"libc/tinystdio/atod_engine.c",
+	"libc/tinystdio/atod_ryu.c",
+	"libc/tinystdio/atof_engine.c",
+	"libc/tinystdio/atof_ryu.c",
+	//"libc/tinystdio/atold_engine.c", // have_long_double and not long_double_equals_double
+	"libc/tinystdio/clearerr.c",
+	"libc/tinystdio/compare_exchange.c",
+	"libc/tinystdio/dtoa_data.c",
+	"libc/tinystdio/dtoa_engine.c",
+	"libc/tinystdio/dtoa_ryu.c",
+	"libc/tinystdio/ecvtbuf.c",
+	"libc/tinystdio/ecvt.c",
+	"libc/tinystdio/ecvt_data.c",
+	"libc/tinystdio/ecvtfbuf.c",
+	"libc/tinystdio/ecvtf.c",
+	"libc/tinystdio/ecvtf_data.c",
+	"libc/tinystdio/exchange.c",
+	//"libc/tinystdio/fclose.c", // posix-io
+	"libc/tinystdio/fcvtbuf.c",
+	"libc/tinystdio/fcvt.c",
+	"libc/tinystdio/fcvtfbuf.c",
+	"libc/tinystdio/fcvtf.c",
+	"libc/tinystdio/fdevopen.c",
+	//"libc/tinystdio/fdopen.c", // posix-io
+	"libc/tinystdio/feof.c",
+	"libc/tinystdio/ferror.c",
+	"libc/tinystdio/fflush.c",
+	"libc/tinystdio/fgetc.c",
+	"libc/tinystdio/fgets.c",
+	"libc/tinystdio/fileno.c",
+	"libc/tinystdio/filestrget.c",
+	"libc/tinystdio/filestrputalloc.c",
+	"libc/tinystdio/filestrput.c",
+	//"libc/tinystdio/fopen.c", // posix-io
+	"libc/tinystdio/fprintf.c",
+	"libc/tinystdio/fputc.c",
+	"libc/tinystdio/fputs.c",
+	"libc/tinystdio/fread.c",
+	"libc/tinystdio/fscanf.c",
+	"libc/tinystdio/fseek.c",
+	"libc/tinystdio/ftell.c",
+	"libc/tinystdio/ftoa_data.c",
+	"libc/tinystdio/ftoa_engine.c",
+	"libc/tinystdio/ftoa_ryu.c",
+	"libc/tinystdio/fwrite.c",
+	"libc/tinystdio/gcvtbuf.c",
+	"libc/tinystdio/gcvt.c",
+	"libc/tinystdio/gcvtfbuf.c",
+	"libc/tinystdio/gcvtf.c",
+	"libc/tinystdio/getchar.c",
+	"libc/tinystdio/gets.c",
+	"libc/tinystdio/matchcaseprefix.c",
+	"libc/tinystdio/perror.c",
+	//"libc/tinystdio/posixiob.c", // posix-io
+	//"libc/tinystdio/posixio.c", // posix-io
+	"libc/tinystdio/printf.c",
+	"libc/tinystdio/putchar.c",
+	"libc/tinystdio/puts.c",
+	"libc/tinystdio/ryu_divpow2.c",
+	"libc/tinystdio/ryu_log10.c",
+	"libc/tinystdio/ryu_log2pow5.c",
+	"libc/tinystdio/ryu_pow5bits.c",
+	"libc/tinystdio/ryu_table.c",
+	"libc/tinystdio/ryu_umul128.c",
+	"libc/tinystdio/scanf.c",
+	"libc/tinystdio/setbuf.c",
+	"libc/tinystdio/setvbuf.c",
+	//"libc/tinystdio/sflags.c", // posix-io
+	"libc/tinystdio/snprintf.c",
+	"libc/tinystdio/snprintfd.c",
+	"libc/tinystdio/snprintff.c",
+	"libc/tinystdio/sprintf.c",
+	"libc/tinystdio/sprintfd.c",
+	"libc/tinystdio/sprintff.c",
+	"libc/tinystdio/sscanf.c",
+	"libc/tinystdio/strfromd.c",
+	"libc/tinystdio/strfromf.c",
+	"libc/tinystdio/strtod.c",
+	"libc/tinystdio/strtod_l.c",
+	"libc/tinystdio/strtof.c",
+	//"libc/tinystdio/strtold.c",   // have_long_double and not long_double_equals_double
+	//"libc/tinystdio/strtold_l.c", // have_long_double and not long_double_equals_double
+	"libc/tinystdio/ungetc.c",
+	"libc/tinystdio/vasprintf.c",
+	"libc/tinystdio/vfiprintf.c",
+	"libc/tinystdio/vfiscanf.c",
+	"libc/tinystdio/vfprintf.c",
+	"libc/tinystdio/vfprintff.c",
+	"libc/tinystdio/vfscanf.c",
+	"libc/tinystdio/vfscanff.c",
+	"libc/tinystdio/vprintf.c",
+	"libc/tinystdio/vscanf.c",
+	"libc/tinystdio/vsnprintf.c",
+	"libc/tinystdio/vsprintf.c",
+	"libc/tinystdio/vsscanf.c",

-	"string/bcmp.c",
-	"string/bcopy.c",
-	"string/bzero.c",
-	"string/explicit_bzero.c",
-	"string/ffsl.c",
-	"string/ffsll.c",
-	"string/fls.c",
-	"string/flsl.c",
-	"string/flsll.c",
-	"string/gnu_basename.c",
-	"string/index.c",
-	"string/memccpy.c",
-	"string/memchr.c",
-	"string/memcmp.c",
-	"string/memcpy.c",
-	"string/memmem.c",
-	"string/memmove.c",
-	"string/mempcpy.c",
-	"string/memrchr.c",
-	"string/memset.c",
-	"string/rawmemchr.c",
-	"string/rindex.c",
-	"string/stpcpy.c",
-	"string/stpncpy.c",
-	"string/strcasecmp.c",
-	"string/strcasecmp_l.c",
-	"string/strcasestr.c",
-	"string/strcat.c",
-	"string/strchr.c",
-	"string/strchrnul.c",
-	"string/strcmp.c",
-	"string/strcoll.c",
-	"string/strcoll_l.c",
-	"string/strcpy.c",
-	"string/strcspn.c",
-	"string/strdup.c",
-	"string/strerror.c",
-	"string/strerror_r.c",
-	"string/strlcat.c",
-	"string/strlcpy.c",
-	"string/strlen.c",
-	"string/strlwr.c",
-	"string/strncasecmp.c",
-	"string/strncasecmp_l.c",
-	"string/strncat.c",
-	"string/strncmp.c",
-	"string/strncpy.c",
-	"string/strndup.c",
-	"string/strnlen.c",
-	"string/strnstr.c",
-	"string/strpbrk.c",
-	"string/strrchr.c",
-	"string/strsep.c",
-	"string/strsignal.c",
-	"string/strspn.c",
-	"string/strstr.c",
-	"string/strtok.c",
-	"string/strtok_r.c",
-	"string/strupr.c",
-	"string/strverscmp.c",
-	"string/strxfrm.c",
-	"string/strxfrm_l.c",
-	"string/swab.c",
-	"string/timingsafe_bcmp.c",
-	"string/timingsafe_memcmp.c",
-	"string/u_strerr.c",
-	"string/wcpcpy.c",
-	"string/wcpncpy.c",
-	"string/wcscasecmp.c",
-	"string/wcscasecmp_l.c",
-	"string/wcscat.c",
-	"string/wcschr.c",
-	"string/wcscmp.c",
-	"string/wcscoll.c",
-	"string/wcscoll_l.c",
-	"string/wcscpy.c",
-	"string/wcscspn.c",
-	"string/wcsdup.c",
-	"string/wcslcat.c",
-	"string/wcslcpy.c",
-	"string/wcslen.c",
-	"string/wcsncasecmp.c",
-	"string/wcsncasecmp_l.c",
-	"string/wcsncat.c",
-	"string/wcsncmp.c",
-	"string/wcsncpy.c",
-	"string/wcsnlen.c",
-	"string/wcspbrk.c",
-	"string/wcsrchr.c",
-	"string/wcsspn.c",
-	"string/wcsstr.c",
-	"string/wcstok.c",
-	"string/wcswidth.c",
-	"string/wcsxfrm.c",
-	"string/wcsxfrm_l.c",
-	"string/wcwidth.c",
-	"string/wmemchr.c",
-	"string/wmemcmp.c",
-	"string/wmemcpy.c",
-	"string/wmemmove.c",
-	"string/wmempcpy.c",
-	"string/wmemset.c",
-	"string/xpg_strerror_r.c",
+	"libc/string/bcmp.c",
+	"libc/string/bcopy.c",
+	"libc/string/bzero.c",
+	"libc/string/explicit_bzero.c",
+	"libc/string/ffsl.c",
+	"libc/string/ffsll.c",
+	"libc/string/fls.c",
+	"libc/string/flsl.c",
+	"libc/string/flsll.c",
+	"libc/string/gnu_basename.c",
+	"libc/string/index.c",
+	"libc/string/memccpy.c",
+	"libc/string/memchr.c",
+	"libc/string/memcmp.c",
+	"libc/string/memcpy.c",
+	"libc/string/memmem.c",
+	"libc/string/memmove.c",
+	"libc/string/mempcpy.c",
+	"libc/string/memrchr.c",
+	"libc/string/memset.c",
+	"libc/string/rawmemchr.c",
+	"libc/string/rindex.c",
+	"libc/string/stpcpy.c",
+	"libc/string/stpncpy.c",
+	"libc/string/strcasecmp.c",
+	"libc/string/strcasecmp_l.c",
+	"libc/string/strcasestr.c",
+	"libc/string/strcat.c",
+	"libc/string/strchr.c",
+	"libc/string/strchrnul.c",
+	"libc/string/strcmp.c",
+	"libc/string/strcoll.c",
+	"libc/string/strcoll_l.c",
+	"libc/string/strcpy.c",
+	"libc/string/strcspn.c",
+	"libc/string/strdup.c",
+	"libc/string/strerror.c",
+	"libc/string/strerror_r.c",
+	"libc/string/strlcat.c",
+	"libc/string/strlcpy.c",
+	"libc/string/strlen.c",
+	"libc/string/strlwr.c",
+	"libc/string/strncasecmp.c",
+	"libc/string/strncasecmp_l.c",
+	"libc/string/strncat.c",
+	"libc/string/strncmp.c",
+	"libc/string/strncpy.c",
+	"libc/string/strndup.c",
+	"libc/string/strnlen.c",
+	"libc/string/strnstr.c",
+	"libc/string/strpbrk.c",
+	"libc/string/strrchr.c",
+	"libc/string/strsep.c",
+	"libc/string/strsignal.c",
+	"libc/string/strspn.c",
+	"libc/string/strstr.c",
+	"libc/string/strtok.c",
+	"libc/string/strtok_r.c",
+	"libc/string/strupr.c",
+	"libc/string/strverscmp.c",
+	"libc/string/strxfrm.c",
+	"libc/string/strxfrm_l.c",
+	"libc/string/swab.c",
+	"libc/string/timingsafe_bcmp.c",
+	"libc/string/timingsafe_memcmp.c",
+	"libc/string/u_strerr.c",
+	"libc/string/wcpcpy.c",
+	"libc/string/wcpncpy.c",
+	"libc/string/wcscasecmp.c",
+	"libc/string/wcscasecmp_l.c",
+	"libc/string/wcscat.c",
+	"libc/string/wcschr.c",
+	"libc/string/wcscmp.c",
+	"libc/string/wcscoll.c",
+	"libc/string/wcscoll_l.c",
+	"libc/string/wcscpy.c",
+	"libc/string/wcscspn.c",
+	"libc/string/wcsdup.c",
+	"libc/string/wcslcat.c",
+	"libc/string/wcslcpy.c",
+	"libc/string/wcslen.c",
+	"libc/string/wcsncasecmp.c",
+	"libc/string/wcsncasecmp_l.c",
+	"libc/string/wcsncat.c",
+	"libc/string/wcsncmp.c",
+	"libc/string/wcsncpy.c",
+	"libc/string/wcsnlen.c",
+	"libc/string/wcspbrk.c",
+	"libc/string/wcsrchr.c",
+	"libc/string/wcsspn.c",
+	"libc/string/wcsstr.c",
+	"libc/string/wcstok.c",
+	"libc/string/wcswidth.c",
+	"libc/string/wcsxfrm.c",
+	"libc/string/wcsxfrm_l.c",
+	"libc/string/wcwidth.c",
+	"libc/string/wmemchr.c",
+	"libc/string/wmemcmp.c",
+	"libc/string/wmemcpy.c",
+	"libc/string/wmemmove.c",
+	"libc/string/wmempcpy.c",
+	"libc/string/wmemset.c",
+	"libc/string/xpg_strerror_r.c",
+
+	"libm/common/sf_finite.c",
+	"libm/common/sf_copysign.c",
+	"libm/common/sf_modf.c",
+	"libm/common/sf_scalbn.c",
+	"libm/common/sf_cbrt.c",
+	"libm/common/sf_exp10.c",
+	"libm/common/sf_expm1.c",
+	"libm/common/sf_ilogb.c",
+	"libm/common/sf_infinity.c",
+	"libm/common/sf_isinf.c",
+	"libm/common/sf_isinff.c",
+	"libm/common/sf_isnan.c",
+	"libm/common/sf_isnanf.c",
+	"libm/common/sf_issignaling.c",
+	"libm/common/sf_log1p.c",
+	"libm/common/sf_nan.c",
+	"libm/common/sf_nextafter.c",
+	"libm/common/sf_pow10.c",
+	"libm/common/sf_rint.c",
+	"libm/common/sf_logb.c",
+	"libm/common/sf_fdim.c",
+	"libm/common/sf_fma.c",
+	"libm/common/sf_fmax.c",
+	"libm/common/sf_fmin.c",
+	"libm/common/sf_fpclassify.c",
+	"libm/common/sf_lrint.c",
+	"libm/common/sf_llrint.c",
+	"libm/common/sf_lround.c",
+	"libm/common/sf_llround.c",
+	"libm/common/sf_nearbyint.c",
+	"libm/common/sf_remquo.c",
+	"libm/common/sf_round.c",
+	"libm/common/sf_scalbln.c",
+	"libm/common/sf_trunc.c",
+	"libm/common/sf_exp.c",
+	"libm/common/sf_exp2.c",
+	"libm/common/sf_exp2_data.c",
+	"libm/common/sf_log.c",
+	"libm/common/sf_log_data.c",
+	"libm/common/sf_log2.c",
+	"libm/common/sf_log2_data.c",
+	"libm/common/sf_pow_log2_data.c",
+	"libm/common/sf_pow.c",
+
+	"libm/common/s_finite.c",
+	"libm/common/s_copysign.c",
+	"libm/common/s_modf.c",
+	"libm/common/s_scalbn.c",
+	"libm/common/s_cbrt.c",
+	"libm/common/s_exp10.c",
+	"libm/common/s_expm1.c",
+	"libm/common/s_ilogb.c",
+	"libm/common/s_infinity.c",
+	"libm/common/s_isinf.c",
+	"libm/common/s_isinfd.c",
+	"libm/common/s_isnan.c",
+	"libm/common/s_isnand.c",
+	"libm/common/s_issignaling.c",
+	"libm/common/s_log1p.c",
+	"libm/common/s_nan.c",
+	"libm/common/s_nextafter.c",
+	"libm/common/s_pow10.c",
+	"libm/common/s_rint.c",
+	"libm/common/s_logb.c",
+	"libm/common/s_log2.c",
+	"libm/common/s_fdim.c",
+	"libm/common/s_fma.c",
+	"libm/common/s_fmax.c",
+	"libm/common/s_fmin.c",
+	"libm/common/s_fpclassify.c",
+	"libm/common/s_lrint.c",
+	"libm/common/s_llrint.c",
+	"libm/common/s_lround.c",
+	"libm/common/s_llround.c",
+	"libm/common/s_nearbyint.c",
+	"libm/common/s_remquo.c",
+	"libm/common/s_round.c",
+	"libm/common/s_scalbln.c",
+	"libm/common/s_signbit.c",
+	"libm/common/s_trunc.c",
+	"libm/common/exp.c",
+	"libm/common/exp2.c",
+	"libm/common/exp_data.c",
+	"libm/common/math_err_with_errno.c",
+	"libm/common/math_err_xflow.c",
+	"libm/common/math_err_uflow.c",
+	"libm/common/math_err_oflow.c",
+	"libm/common/math_err_divzero.c",
+	"libm/common/math_err_invalid.c",
+	"libm/common/math_err_may_uflow.c",
+	"libm/common/math_err_check_uflow.c",
+	"libm/common/math_err_check_oflow.c",
+	"libm/common/log.c",
+	"libm/common/log_data.c",
+	"libm/common/log2.c",
+	"libm/common/log2_data.c",
+	"libm/common/pow.c",
+	"libm/common/pow_log_data.c",
+
+	"libm/math/e_acos.c",
+	"libm/math/e_acosh.c",
+	"libm/math/e_asin.c",
+	"libm/math/e_atan2.c",
+	"libm/math/e_atanh.c",
+	"libm/math/e_cosh.c",
+	"libm/math/e_exp.c",
+	"libm/math/ef_acos.c",
+	"libm/math/ef_acosh.c",
+	"libm/math/ef_asin.c",
+	"libm/math/ef_atan2.c",
+	"libm/math/ef_atanh.c",
+	"libm/math/ef_cosh.c",
+	"libm/math/ef_exp.c",
+	"libm/math/ef_fmod.c",
+	"libm/math/ef_hypot.c",
+	"libm/math/ef_j0.c",
+	"libm/math/ef_j1.c",
+	"libm/math/ef_jn.c",
+	"libm/math/ef_lgamma.c",
+	"libm/math/ef_log10.c",
+	"libm/math/ef_log.c",
+	"libm/math/e_fmod.c",
+	"libm/math/ef_pow.c",
+	"libm/math/ef_remainder.c",
+	"libm/math/ef_rem_pio2.c",
+	"libm/math/ef_scalb.c",
+	"libm/math/ef_sinh.c",
+	"libm/math/ef_sqrt.c",
+	"libm/math/ef_tgamma.c",
+	"libm/math/e_hypot.c",
+	"libm/math/e_j0.c",
+	"libm/math/e_j1.c",
+	"libm/math/e_jn.c",
+	"libm/math/e_lgamma.c",
+	"libm/math/e_log10.c",
+	"libm/math/e_log.c",
+	"libm/math/e_pow.c",
+	"libm/math/e_remainder.c",
+	"libm/math/e_rem_pio2.c",
+	"libm/math/erf_lgamma.c",
+	"libm/math/er_lgamma.c",
+	"libm/math/e_scalb.c",
+	"libm/math/e_sinh.c",
+	"libm/math/e_sqrt.c",
+	"libm/math/e_tgamma.c",
+	"libm/math/s_asinh.c",
+	"libm/math/s_atan.c",
+	"libm/math/s_ceil.c",
+	"libm/math/s_cos.c",
+	"libm/math/s_erf.c",
+	"libm/math/s_fabs.c",
+	"libm/math/sf_asinh.c",
+	"libm/math/sf_atan.c",
+	"libm/math/sf_ceil.c",
+	"libm/math/sf_cos.c",
+	"libm/math/sf_erf.c",
+	"libm/math/sf_fabs.c",
+	"libm/math/sf_floor.c",
+	"libm/math/sf_frexp.c",
+	"libm/math/sf_ldexp.c",
+	"libm/math/s_floor.c",
+	"libm/math/s_frexp.c",
+	"libm/math/sf_signif.c",
+	"libm/math/sf_sin.c",
+	"libm/math/sf_tan.c",
+	"libm/math/sf_tanh.c",
+	"libm/math/s_ldexp.c",
+	"libm/math/s_signif.c",
+	"libm/math/s_sin.c",
+	"libm/math/s_tan.c",
+	"libm/math/s_tanh.c",
 }
@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"debug/dwarf"
 	"debug/elf"
+	"debug/macho"
 	"debug/pe"
 	"encoding/binary"
 	"fmt"
@@ -116,7 +117,7 @@ var (
 	//   alloc:  heap allocations during init interpretation
 	//   pack:   data created when storing a constant in an interface for example
 	//   string: buffer behind strings
-	packageSymbolRegexp = regexp.MustCompile(`\$(alloc|pack|string)(\.[0-9]+)?$`)
+	packageSymbolRegexp = regexp.MustCompile(`\$(alloc|embedfsfiles|embedfsslice|embedslice|pack|string)(\.[0-9]+)?$`)

 	// Reflect sidetables. Created by the reflect lowering pass.
 	// See src/reflect/sidetables.go.
@@ -126,7 +127,7 @@ var (
 // readProgramSizeFromDWARF reads the source location for each line of code and
 // each variable in the program, as far as this is stored in the DWARF debug
 // information.
-func readProgramSizeFromDWARF(data *dwarf.Data, codeOffset uint64) ([]addressLine, error) {
+func readProgramSizeFromDWARF(data *dwarf.Data, codeOffset uint64, skipTombstone bool) ([]addressLine, error) {
 	r := data.Reader()
 	var lines []*dwarf.LineFile
 	var addresses []addressLine
@@ -168,7 +169,7 @@ func readProgramSizeFromDWARF(data *dwarf.Data, codeOffset uint64) ([]addressLin
 					return nil, err
 				}

-				if prevLineEntry.EndSequence && lineEntry.Address == 0 {
+				if prevLineEntry.EndSequence && lineEntry.Address == 0 && skipTombstone {
 					// Tombstone value. This symbol has been removed, for
 					// example by the --gc-sections linker flag. It is still
 					// here in the debug information because the linker can't
@@ -177,6 +178,10 @@ func readProgramSizeFromDWARF(data *dwarf.Data, codeOffset uint64) ([]addressLin
 					// skipped.
 					// For more details, see (among others):
 					// https://reviews.llvm.org/D84825
+					// The value 0 can however really occur in object files,
+					// that typically start at address 0. So don't skip
+					// tombstone values in object files (like when parsing MachO
+					// files).
 					for {
 						err := lr.Next(&lineEntry)
 						if err != nil {
@@ -255,6 +260,65 @@ func readProgramSizeFromDWARF(data *dwarf.Data, codeOffset uint64) ([]addressLin
 	return addresses, nil
 }

+// Read a MachO object file and return a line table.
+// Also return an index from symbol name to start address in the line table.
+func readMachOSymbolAddresses(path string) (map[string]int, []addressLine, error) {
+	// Some constants from mach-o/nlist.h
+	// See: https://opensource.apple.com/source/xnu/xnu-7195.141.2/EXTERNAL_HEADERS/mach-o/nlist.h.auto.html
+	const (
+		N_STAB = 0xe0
+		N_TYPE = 0x0e // bitmask for N_TYPE field
+		N_SECT = 0xe  // one of the possible type in the N_TYPE field
+	)
+
+	// Read DWARF from the given object file.
+	file, err := macho.Open(path)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer file.Close()
+	dwarf, err := file.DWARF()
+	if err != nil {
+		return nil, nil, err
+	}
+	lines, err := readProgramSizeFromDWARF(dwarf, 0, false)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// Make a map from start addresses to indices in the line table (because the
+	// line table is a slice, not a map).
+	addressToLine := make(map[uint64]int, len(lines))
+	for i, line := range lines {
+		if _, ok := addressToLine[line.Address]; ok {
+			addressToLine[line.Address] = -1
+			continue
+		}
+		addressToLine[line.Address] = i
+	}
+
+	// Make a map that for each symbol gives the start index in the line table.
+	addresses := make(map[string]int, len(addressToLine))
+	for _, symbol := range file.Symtab.Syms {
+		if symbol.Type&N_STAB != 0 {
+			continue // STABS entry, ignore
+		}
+		if symbol.Type&0x0e != N_SECT {
+			continue // undefined symbol
+		}
+		if index, ok := addressToLine[symbol.Value]; ok && index >= 0 {
+			if _, ok := addresses[symbol.Name]; ok {
+				// There is a duplicate. Mark it as unavailable.
+				addresses[symbol.Name] = -1
+				continue
+			}
+			addresses[symbol.Name] = index
+		}
+	}
+
+	return addresses, lines, nil
+}
+
 // loadProgramSize calculate a program/data size breakdown of each package for a
 // given ELF file.
 // If the file doesn't contain DWARF debug information, the returned program
@@ -277,7 +341,7 @@ func loadProgramSize(path string, packagePathMap map[string]string) (*programSiz
 		// Read DWARF information. The error is intentionally ignored.
 		data, _ := file.DWARF()
 		if data != nil {
-			addresses, err = readProgramSizeFromDWARF(data, 0)
+			addresses, err = readProgramSizeFromDWARF(data, 0, true)
 			if err != nil {
 				// However, _do_ report an error here. Something must have gone
 				// wrong while trying to parse DWARF data.
@@ -368,11 +432,133 @@ func loadProgramSize(path string, packagePathMap map[string]string) (*programSiz
 				})
 			}
 		}
+	} else if file, err := macho.NewFile(f); err == nil {
+		// Read segments, for use while reading through sections.
+		segments := map[string]*macho.Segment{}
+		for _, load := range file.Loads {
+			switch load := load.(type) {
+			case *macho.Segment:
+				segments[load.Name] = load
+			}
+		}
+
+		// Read MachO sections.
+		for _, section := range file.Sections {
+			sectionType := section.Flags & 0xff
+			sectionFlags := section.Flags >> 8
+			segment := segments[section.Seg]
+			// For the constants used here, see:
+			// https://github.com/llvm/llvm-project/blob/release/14.x/llvm/include/llvm/BinaryFormat/MachO.h
+			if sectionFlags&0x800000 != 0 { // S_ATTR_PURE_INSTRUCTIONS
+				// Section containing only instructions.
+				sections = append(sections, memorySection{
+					Address: section.Addr,
+					Size:    uint64(section.Size),
+					Type:    memoryCode,
+				})
+			} else if sectionType == 1 { // S_ZEROFILL
+				// Section filled with zeroes on demand.
+				sections = append(sections, memorySection{
+					Address: section.Addr,
+					Size:    uint64(section.Size),
+					Type:    memoryBSS,
+				})
+			} else if segment.Maxprot&0b011 == 0b001 { // --r (read-only data)
+				// Protection doesn't allow writes, so mark this section read-only.
+				sections = append(sections, memorySection{
+					Address: section.Addr,
+					Size:    uint64(section.Size),
+					Type:    memoryROData,
+				})
+			} else {
+				// The rest is assumed to be regular data.
+				sections = append(sections, memorySection{
+					Address: section.Addr,
+					Size:    uint64(section.Size),
+					Type:    memoryData,
+				})
+			}
+		}
+
+		// Read DWARF information.
+		// The data isn't stored directly in the binary as in most executable
+		// formats. Instead, it is left in the object files that were used as a
+		// basis for linking. The executable does however contain STABS debug
+		// information that points to the source object file and is used by
+		// debuggers.
+		// For more information:
+		// http://wiki.dwarfstd.org/index.php?title=Apple%27s_%22Lazy%22_DWARF_Scheme
+		var objSymbolNames map[string]int
+		var objAddresses []addressLine
+		var previousSymbol macho.Symbol
+		for _, symbol := range file.Symtab.Syms {
+			// STABS constants, from mach-o/stab.h:
+			// https://opensource.apple.com/source/xnu/xnu-7195.141.2/EXTERNAL_HEADERS/mach-o/stab.h.auto.html
+			const (
+				N_GSYM  = 0x20
+				N_FUN   = 0x24
+				N_STSYM = 0x26
+				N_SO    = 0x64
+				N_OSO   = 0x66
+			)
+			if symbol.Type == N_OSO {
+				// Found an object file. Now try to parse it.
+				objSymbolNames, objAddresses, err = readMachOSymbolAddresses(symbol.Name)
+				if err != nil && sizesDebug {
+					// Errors are normally ignored. If there is an error, it's
+					// simply treated as that the DWARF is not available.
+					fmt.Fprintf(os.Stderr, "could not read DWARF from file %s: %s\n", symbol.Name, err)
+				}
+			} else if symbol.Type == N_FUN {
+				// Found a function.
+				// The way this is encoded is a bit weird. MachO symbols don't
+				// have a length. What I've found is that the length is encoded
+				// by first having a N_FUN symbol as usual, and then having a
+				// symbol with a zero-length name that has the value not set to
+				// the address of the symbol but to the length. So in order to
+				// get both the address and the length, we look for a symbol
+				// with a name followed by a symbol without a name.
+				if symbol.Name == "" && previousSymbol.Type == N_FUN && previousSymbol.Name != "" {
+					// Functions are encoded as many small chunks in the line
+					// table (one or a few instructions per source line). But
+					// the symbol length covers the whole symbols, over many
+					// lines and possibly including inlined functions. So we
+					// continue to iterate through the objAddresses slice until
+					// we've found all the source lines that are part of this
+					// symbol.
+					address := previousSymbol.Value
+					length := symbol.Value
+					if index, ok := objSymbolNames[previousSymbol.Name]; ok && index >= 0 {
+						for length > 0 {
+							line := objAddresses[index]
+							line.Address = address
+							if line.Length > length {
+								// Line extends beyond the end of te symbol?
+								// Weird, shouldn't happen.
+								break
+							}
+							addresses = append(addresses, line)
+							index++
+							length -= line.Length
+							address += line.Length
+						}
+					}
+				}
+			} else if symbol.Type == N_GSYM || symbol.Type == N_STSYM {
+				// Global variables.
+				if index, ok := objSymbolNames[symbol.Name]; ok {
+					address := objAddresses[index]
+					address.Address = symbol.Value
+					addresses = append(addresses, address)
+				}
+			}
+			previousSymbol = symbol
+		}
 	} 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)
+			addresses, err = readProgramSizeFromDWARF(data, 0, true)
 			if err != nil {
 				// However, _do_ report an error here. Something must have gone
 				// wrong while trying to parse DWARF data.
@@ -442,9 +628,9 @@ func loadProgramSize(path string, packagePathMap map[string]string) (*programSiz
 		const codeOffset = 0x8000_0000_0000_0000

 		// Read DWARF information. The error is intentionally ignored.
-		data, err := file.DWARF()
+		data, _ := file.DWARF()
 		if data != nil {
-			addresses, err = readProgramSizeFromDWARF(data, codeOffset)
+			addresses, err = readProgramSizeFromDWARF(data, codeOffset, true)
 			if err != nil {
 				// However, _do_ report an error here. Something must have gone
 				// wrong while trying to parse DWARF data.
@@ -1,3 +1,4 @@
+//go:build byollvm
 // +build byollvm

 package builder
@@ -13,6 +14,7 @@ import (
 #include <stdlib.h>
 bool tinygo_clang_driver(int argc, char **argv);
 bool tinygo_link_elf(int argc, char **argv);
+bool tinygo_link_macho(int argc, char **argv);
 bool tinygo_link_mingw(int argc, char **argv);
 bool tinygo_link_wasm(int argc, char **argv);
 */
@@ -26,8 +28,13 @@ const hasBuiltinTools = true
 // linking statically with LLVM (with the byollvm build tag).
 func RunTool(tool string, args ...string) error {
 	linker := "elf"
-	if tool == "ld.lld" && len(args) >= 2 && args[0] == "-m" && args[1] == "i386pep" {
-		linker = "mingw"
+	if tool == "ld.lld" && len(args) >= 2 {
+		if args[0] == "-m" && args[1] == "i386pep" {
+			linker = "mingw"
+		} else if args[0] == "-flavor" {
+			linker = args[1]
+			args = args[2:]
+		}
 	}
 	args = append([]string{"tinygo:" + tool}, args...)

@@ -47,6 +54,8 @@ func RunTool(tool string, args ...string) error {
 		ok = C.tinygo_clang_driver(C.int(len(args)), (**C.char)(buf))
 	case "ld.lld":
 		switch linker {
+		case "darwin":
+			ok = C.tinygo_link_macho(C.int(len(args)), (**C.char)(buf))
 		case "elf":
 			ok = C.tinygo_link_elf(C.int(len(args)), (**C.char)(buf))
 		case "mingw":
@@ -1,3 +1,4 @@
+//go:build !byollvm
 // +build !byollvm

 package builder
@@ -10,7 +10,7 @@ package builder
 import (
 	"bytes"
 	"encoding/binary"
-	"io/ioutil"
+	"os"
 	"strconv"
 )

@@ -26,7 +26,7 @@ func convertELFFileToUF2File(infile, outfile string, uf2FamilyID string) error {
 	if err != nil {
 		return err
 	}
-	return ioutil.WriteFile(outfile, output, 0644)
+	return os.WriteFile(outfile, output, 0644)
 }

 // convertBinToUF2 converts the binary bytes in input to UF2 formatted data.
@@ -5,12 +5,11 @@ import (
 	"flag"
 	"fmt"
 	"go/ast"
-	"go/build"
 	"go/format"
 	"go/parser"
 	"go/token"
 	"go/types"
-	"io/ioutil"
+	"os"
 	"path/filepath"
 	"runtime"
 	"strings"
@@ -40,20 +39,6 @@ func TestCGo(t *testing.T) {
 	} {
 		name := name // avoid a race condition
 		t.Run(name, func(t *testing.T) {
-			// Skip tests that require specific Go version.
-			if name == "errors" {
-				ok := false
-				for _, version := range build.Default.ReleaseTags {
-					if version == "go1.16" {
-						ok = true
-						break
-					}
-				}
-				if !ok {
-					t.Skip("Results for errors test are only valid for Go 1.16+")
-				}
-			}
-
 			// Read the AST in memory.
 			path := filepath.Join("testdata", name+".go")
 			fset := token.NewFileSet()
@@ -63,7 +48,7 @@ func TestCGo(t *testing.T) {
 			}

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

 			// Check the AST for type errors.
 			var typecheckErrors []error
@@ -107,7 +92,7 @@ func TestCGo(t *testing.T) {

 			// Read the file with the expected output, to compare against.
 			outfile := filepath.Join("testdata", name+".out.go")
-			expectedBytes, err := ioutil.ReadFile(outfile)
+			expectedBytes, err := os.ReadFile(outfile)
 			if err != nil {
 				t.Fatalf("could not read expected output: %v", err)
 			}
@@ -118,7 +103,7 @@ func TestCGo(t *testing.T) {
 				// It is not. Test failed.
 				if *flagUpdate {
 					// Update the file with the expected data.
-					err := ioutil.WriteFile(outfile, []byte(actual), 0666)
+					err := os.WriteFile(outfile, []byte(actual), 0666)
 					if err != nil {
 						t.Error("could not write updated output file:", err)
 					}
@@ -13,10 +13,13 @@ import (
 	"strconv"
 	"strings"
 	"unsafe"
+
+	"tinygo.org/x/go-llvm"
 )

 /*
-#include <clang-c/Index.h> // if this fails, install libclang-11-dev
+#include <clang-c/Index.h> // If this fails, libclang headers aren't available. Please take a look here: https://tinygo.org/docs/guides/build/
+#include <llvm/Config/llvm-config.h>
 #include <stdlib.h>
 #include <stdint.h>

@@ -72,7 +75,21 @@ var diagnosticSeverity = [...]string{
 	C.CXDiagnostic_Fatal:   "fatal",
 }

-func (p *cgoPackage) parseFragment(fragment string, cflags []string, filename string) {
+// Alias so that cgo.go (which doesn't import Clang related stuff and is in
+// theory decoupled from Clang) can also use this type.
+type clangCursor = C.GoCXCursor
+
+func init() {
+	// Check that we haven't messed up LLVM versioning.
+	// This can happen when llvm_config_*.go files in either this or the
+	// tinygo.org/x/go-llvm packages is incorrect. It should not ever happen
+	// with byollvm.
+	if C.LLVM_VERSION_STRING != llvm.Version {
+		panic("incorrect build: using LLVM version " + llvm.Version + " in the tinygo.org/x/llvm package, and version " + C.LLVM_VERSION_STRING + " in the ./cgo package")
+	}
+}
+
+func (f *cgoFile) readNames(fragment string, cflags []string, filename string, callback func(map[string]clangCursor)) {
 	index := C.clang_createIndex(0, 0)
 	defer C.clang_disposeIndex(index)

@@ -119,8 +136,8 @@ func (p *cgoPackage) parseFragment(fragment string, cflags []string, filename st
 			spelling := getString(C.clang_getDiagnosticSpelling(diagnostic))
 			severity := diagnosticSeverity[C.clang_getDiagnosticSeverity(diagnostic)]
 			location := C.clang_getDiagnosticLocation(diagnostic)
-			pos := p.getClangLocationPosition(location, unit)
-			p.addError(pos, severity+": "+spelling)
+			pos := f.getClangLocationPosition(location, unit)
+			f.addError(pos, severity+": "+spelling)
 		}
 		for i := 0; i < numDiagnostics; i++ {
 			diagnostic := C.clang_getDiagnostic(unit, C.uint(i))
@@ -135,7 +152,7 @@ func (p *cgoPackage) parseFragment(fragment string, cflags []string, filename st
 	}

 	// Extract information required by CGo.
-	ref := storedRefs.Put(p)
+	ref := storedRefs.Put(f)
 	defer storedRefs.Remove(ref)
 	cursor := C.tinygo_clang_getTranslationUnitCursor(unit)
 	C.tinygo_clang_visitChildren(cursor, C.CXCursorVisitor(C.tinygo_clang_globals_visitor), C.CXClientData(ref))
@@ -155,35 +172,64 @@ func (p *cgoPackage) parseFragment(fragment string, cflags []string, filename st
 		data := (*[1 << 24]byte)(unsafe.Pointer(rawData))[:size]

 		// Hash the contents if it isn't hashed yet.
-		if _, ok := p.visitedFiles[path]; !ok {
+		if _, ok := f.visitedFiles[path]; !ok {
 			// already stored
 			sum := sha512.Sum512_224(data)
-			p.visitedFiles[path] = sum[:]
+			f.visitedFiles[path] = sum[:]
 		}
 	}
 	inclusionCallbackRef := storedRefs.Put(inclusionCallback)
 	defer storedRefs.Remove(inclusionCallbackRef)
 	C.clang_getInclusions(unit, C.CXInclusionVisitor(C.tinygo_clang_inclusion_visitor), C.CXClientData(inclusionCallbackRef))
+
+	// Do all the C AST operations inside a callback. This makes sure that
+	// libclang related memory is only freed after it is not necessary anymore.
+	callback(f.names)
 }

-//export tinygo_clang_globals_visitor
-func tinygo_clang_globals_visitor(c, parent C.GoCXCursor, client_data C.CXClientData) C.int {
-	p := storedRefs.Get(unsafe.Pointer(client_data)).(*cgoPackage)
+// Convert the AST node under the given Clang cursor to a Go AST node and return
+// it.
+func (f *cgoFile) createASTNode(name string, c clangCursor) (ast.Node, *elaboratedTypeInfo) {
 	kind := C.tinygo_clang_getCursorKind(c)
-	pos := p.getCursorPosition(c)
+	pos := f.getCursorPosition(c)
 	switch kind {
 	case C.CXCursor_FunctionDecl:
-		name := getString(C.tinygo_clang_getCursorSpelling(c))
-		if _, required := p.missingSymbols[name]; !required {
-			return C.CXChildVisit_Continue
-		}
 		cursorType := C.tinygo_clang_getCursorType(c)
 		numArgs := int(C.tinygo_clang_Cursor_getNumArguments(c))
-		fn := &functionInfo{
-			pos:      pos,
-			variadic: C.clang_isFunctionTypeVariadic(cursorType) != 0,
+		obj := &ast.Object{
+			Kind: ast.Fun,
+			Name: "C." + name,
+		}
+		args := make([]*ast.Field, numArgs)
+		decl := &ast.FuncDecl{
+			Doc: &ast.CommentGroup{
+				List: []*ast.Comment{
+					{
+						Slash: pos - 1,
+						Text:  "//export " + name,
+					},
+				},
+			},
+			Name: &ast.Ident{
+				NamePos: pos,
+				Name:    "C." + name,
+				Obj:     obj,
+			},
+			Type: &ast.FuncType{
+				Func: pos,
+				Params: &ast.FieldList{
+					Opening: pos,
+					List:    args,
+					Closing: pos,
+				},
+			},
+		}
+		if C.clang_isFunctionTypeVariadic(cursorType) != 0 {
+			decl.Doc.List = append(decl.Doc.List, &ast.Comment{
+				Slash: pos - 1,
+				Text:  "//go:variadic",
+			})
 		}
-		p.functions[name] = fn
 		for i := 0; i < numArgs; i++ {
 			arg := C.tinygo_clang_Cursor_getArgument(c, C.uint(i))
 			argName := getString(C.tinygo_clang_getCursorSpelling(arg))
@@ -191,50 +237,108 @@ func tinygo_clang_globals_visitor(c, parent C.GoCXCursor, client_data C.CXClient
 			if argName == "" {
 				argName = "$" + strconv.Itoa(i)
 			}
-			fn.args = append(fn.args, paramInfo{
-				name:     argName,
-				typeExpr: p.makeDecayingASTType(argType, pos),
-			})
+			args[i] = &ast.Field{
+				Names: []*ast.Ident{
+					{
+						NamePos: pos,
+						Name:    argName,
+						Obj: &ast.Object{
+							Kind: ast.Var,
+							Name: argName,
+							Decl: decl,
+						},
+					},
+				},
+				Type: f.makeDecayingASTType(argType, pos),
+			}
 		}
 		resultType := C.tinygo_clang_getCursorResultType(c)
 		if resultType.kind != C.CXType_Void {
-			fn.results = &ast.FieldList{
+			decl.Type.Results = &ast.FieldList{
 				List: []*ast.Field{
 					{
-						Type: p.makeASTType(resultType, pos),
+						Type: f.makeASTType(resultType, pos),
 					},
 				},
 			}
 		}
-	case C.CXCursor_StructDecl:
-		typ := C.tinygo_clang_getCursorType(c)
-		name := getString(C.tinygo_clang_getCursorSpelling(c))
-		if _, required := p.missingSymbols["struct_"+name]; !required {
-			return C.CXChildVisit_Continue
+		obj.Decl = decl
+		return decl, nil
+	case C.CXCursor_StructDecl, C.CXCursor_UnionDecl:
+		typ := f.makeASTRecordType(c, pos)
+		typeName := "C." + name
+		typeExpr := typ.typeExpr
+		if typ.unionSize != 0 {
+			// Convert to a single-field struct type.
+			typeExpr = f.makeUnionField(typ)
 		}
-		p.makeASTType(typ, pos)
+		obj := &ast.Object{
+			Kind: ast.Typ,
+			Name: typeName,
+		}
+		typeSpec := &ast.TypeSpec{
+			Name: &ast.Ident{
+				NamePos: typ.pos,
+				Name:    typeName,
+				Obj:     obj,
+			},
+			Type: typeExpr,
+		}
+		obj.Decl = typeSpec
+		return typeSpec, typ
 	case C.CXCursor_TypedefDecl:
-		typedefType := C.tinygo_clang_getCursorType(c)
-		name := getString(C.clang_getTypedefName(typedefType))
-		if _, required := p.missingSymbols[name]; !required {
-			return C.CXChildVisit_Continue
+		typeName := "C." + name
+		underlyingType := C.tinygo_clang_getTypedefDeclUnderlyingType(c)
+		obj := &ast.Object{
+			Kind: ast.Typ,
+			Name: typeName,
 		}
-		p.makeASTType(typedefType, pos)
+		typeSpec := &ast.TypeSpec{
+			Name: &ast.Ident{
+				NamePos: pos,
+				Name:    typeName,
+				Obj:     obj,
+			},
+			Type: f.makeASTType(underlyingType, pos),
+		}
+		if underlyingType.kind != C.CXType_Enum {
+			typeSpec.Assign = pos
+		}
+		obj.Decl = typeSpec
+		return typeSpec, nil
 	case C.CXCursor_VarDecl:
-		name := getString(C.tinygo_clang_getCursorSpelling(c))
-		if _, required := p.missingSymbols[name]; !required {
-			return C.CXChildVisit_Continue
-		}
 		cursorType := C.tinygo_clang_getCursorType(c)
-		p.globals[name] = globalInfo{
-			typeExpr: p.makeASTType(cursorType, pos),
-			pos:      pos,
+		typeExpr := f.makeASTType(cursorType, pos)
+		gen := &ast.GenDecl{
+			TokPos: pos,
+			Tok:    token.VAR,
+			Lparen: token.NoPos,
+			Rparen: token.NoPos,
+			Doc: &ast.CommentGroup{
+				List: []*ast.Comment{
+					{
+						Slash: pos - 1,
+						Text:  "//go:extern " + name,
+					},
+				},
+			},
 		}
+		obj := &ast.Object{
+			Kind: ast.Var,
+			Name: "C." + name,
+		}
+		valueSpec := &ast.ValueSpec{
+			Names: []*ast.Ident{{
+				NamePos: pos,
+				Name:    "C." + name,
+				Obj:     obj,
+			}},
+			Type: typeExpr,
+		}
+		obj.Decl = valueSpec
+		gen.Specs = append(gen.Specs, valueSpec)
+		return gen, nil
 	case C.CXCursor_MacroDefinition:
-		name := getString(C.tinygo_clang_getCursorSpelling(c))
-		if _, required := p.missingSymbols[name]; !required {
-			return C.CXChildVisit_Continue
-		}
 		sourceRange := C.tinygo_clang_getCursorExtent(c)
 		start := C.clang_getRangeStart(sourceRange)
 		end := C.clang_getRangeEnd(sourceRange)
@@ -242,17 +346,17 @@ func tinygo_clang_globals_visitor(c, parent C.GoCXCursor, client_data C.CXClient
 		var startOffset, endOffset C.unsigned
 		C.clang_getExpansionLocation(start, &file, nil, nil, &startOffset)
 		if file == nil {
-			p.addError(pos, "internal error: could not find file where macro is defined")
-			break
+			f.addError(pos, "internal error: could not find file where macro is defined")
+			return nil, nil
 		}
 		C.clang_getExpansionLocation(end, &endFile, nil, nil, &endOffset)
 		if file != endFile {
-			p.addError(pos, "internal error: expected start and end location of a macro to be in the same file")
-			break
+			f.addError(pos, "internal error: expected start and end location of a macro to be in the same file")
+			return nil, nil
 		}
 		if startOffset > endOffset {
-			p.addError(pos, "internal error: start offset of macro is after end offset")
-			break
+			f.addError(pos, "internal error: start offset of macro is after end offset")
+			return nil, nil
 		}

 		// read file contents and extract the relevant byte range
@@ -260,31 +364,94 @@ func tinygo_clang_globals_visitor(c, parent C.GoCXCursor, client_data C.CXClient
 		var size C.size_t
 		sourcePtr := C.clang_getFileContents(tu, file, &size)
 		if endOffset >= C.uint(size) {
-			p.addError(pos, "internal error: end offset of macro lies after end of file")
-			break
+			f.addError(pos, "internal error: end offset of macro lies after end of file")
+			return nil, nil
 		}
 		source := string(((*[1 << 28]byte)(unsafe.Pointer(sourcePtr)))[startOffset:endOffset:endOffset])
 		if !strings.HasPrefix(source, name) {
-			p.addError(pos, fmt.Sprintf("internal error: expected macro value to start with %#v, got %#v", name, source))
-			break
+			f.addError(pos, fmt.Sprintf("internal error: expected macro value to start with %#v, got %#v", name, source))
+			return nil, nil
 		}
 		value := source[len(name):]
 		// Try to convert this #define into a Go constant expression.
-		expr, scannerError := parseConst(pos+token.Pos(len(name)), p.fset, value)
+		expr, scannerError := parseConst(pos+token.Pos(len(name)), f.fset, value)
 		if scannerError != nil {
-			p.errors = append(p.errors, *scannerError)
+			f.errors = append(f.errors, *scannerError)
+			return nil, nil
 		}
-		if expr != nil {
-			// Parsing was successful.
-			p.constants[name] = constantInfo{expr, pos}
+
+		gen := &ast.GenDecl{
+			TokPos: token.NoPos,
+			Tok:    token.CONST,
+			Lparen: token.NoPos,
+			Rparen: token.NoPos,
 		}
+		obj := &ast.Object{
+			Kind: ast.Con,
+			Name: "C." + name,
+		}
+		valueSpec := &ast.ValueSpec{
+			Names: []*ast.Ident{{
+				NamePos: pos,
+				Name:    "C." + name,
+				Obj:     obj,
+			}},
+			Values: []ast.Expr{expr},
+		}
+		obj.Decl = valueSpec
+		gen.Specs = append(gen.Specs, valueSpec)
+		return gen, nil
 	case C.CXCursor_EnumDecl:
-		// Visit all enums, because the fields may be used even when the enum
-		// type itself is not.
-		typ := C.tinygo_clang_getCursorType(c)
-		p.makeASTType(typ, pos)
+		obj := &ast.Object{
+			Kind: ast.Typ,
+			Name: "C." + name,
+		}
+		underlying := C.tinygo_clang_getEnumDeclIntegerType(c)
+		// TODO: gc's CGo implementation uses types such as `uint32` for enums
+		// instead of types such as C.int, which are used here.
+		typeSpec := &ast.TypeSpec{
+			Name: &ast.Ident{
+				NamePos: pos,
+				Name:    "C." + name,
+				Obj:     obj,
+			},
+			Assign: pos,
+			Type:   f.makeASTType(underlying, pos),
+		}
+		obj.Decl = typeSpec
+		return typeSpec, nil
+	case C.CXCursor_EnumConstantDecl:
+		value := C.tinygo_clang_getEnumConstantDeclValue(c)
+		expr := &ast.BasicLit{
+			ValuePos: pos,
+			Kind:     token.INT,
+			Value:    strconv.FormatInt(int64(value), 10),
+		}
+		gen := &ast.GenDecl{
+			TokPos: token.NoPos,
+			Tok:    token.CONST,
+			Lparen: token.NoPos,
+			Rparen: token.NoPos,
+		}
+		obj := &ast.Object{
+			Kind: ast.Con,
+			Name: "C." + name,
+		}
+		valueSpec := &ast.ValueSpec{
+			Names: []*ast.Ident{{
+				NamePos: pos,
+				Name:    "C." + name,
+				Obj:     obj,
+			}},
+			Values: []ast.Expr{expr},
+		}
+		obj.Decl = valueSpec
+		gen.Specs = append(gen.Specs, valueSpec)
+		return gen, nil
+	default:
+		f.addError(pos, fmt.Sprintf("internal error: unknown cursor type: %d", kind))
+		return nil, nil
 	}
-	return C.CXChildVisit_Continue
 }

 func getString(clangString C.CXString) (s string) {
@@ -294,6 +461,49 @@ func getString(clangString C.CXString) (s string) {
 	return
 }

+//export tinygo_clang_globals_visitor
+func tinygo_clang_globals_visitor(c, parent C.GoCXCursor, client_data C.CXClientData) C.int {
+	f := storedRefs.Get(unsafe.Pointer(client_data)).(*cgoFile)
+	switch C.tinygo_clang_getCursorKind(c) {
+	case C.CXCursor_FunctionDecl:
+		name := getString(C.tinygo_clang_getCursorSpelling(c))
+		f.names[name] = c
+	case C.CXCursor_StructDecl:
+		name := getString(C.tinygo_clang_getCursorSpelling(c))
+		if name != "" {
+			f.names["struct_"+name] = c
+		}
+	case C.CXCursor_UnionDecl:
+		name := getString(C.tinygo_clang_getCursorSpelling(c))
+		if name != "" {
+			f.names["union_"+name] = c
+		}
+	case C.CXCursor_TypedefDecl:
+		typedefType := C.tinygo_clang_getCursorType(c)
+		name := getString(C.clang_getTypedefName(typedefType))
+		f.names[name] = c
+	case C.CXCursor_VarDecl:
+		name := getString(C.tinygo_clang_getCursorSpelling(c))
+		f.names[name] = c
+	case C.CXCursor_MacroDefinition:
+		name := getString(C.tinygo_clang_getCursorSpelling(c))
+		f.names[name] = c
+	case C.CXCursor_EnumDecl:
+		name := getString(C.tinygo_clang_getCursorSpelling(c))
+		if name != "" {
+			// Named enum, which can be referenced from Go using C.enum_foo.
+			f.names["enum_"+name] = c
+		}
+		// The enum fields are in global scope, so recurse to visit them.
+		return C.CXChildVisit_Recurse
+	case C.CXCursor_EnumConstantDecl:
+		// We arrive here because of the "Recurse" above.
+		name := getString(C.tinygo_clang_getCursorSpelling(c))
+		f.names[name] = c
+	}
+	return C.CXChildVisit_Continue
+}
+
 // getCursorPosition returns a usable token.Pos from a libclang cursor.
 func (p *cgoPackage) getCursorPosition(cursor C.GoCXCursor) token.Pos {
 	return p.getClangLocationPosition(C.tinygo_clang_getCursorLocation(cursor), C.tinygo_clang_Cursor_getTranslationUnit(cursor))
@@ -391,7 +601,7 @@ func (p *cgoPackage) addErrorAt(position token.Position, msg string) {
 // makeDecayingASTType does the same as makeASTType but takes care of decaying
 // types (arrays in function parameters, etc). It is otherwise identical to
 // makeASTType.
-func (p *cgoPackage) makeDecayingASTType(typ C.CXType, pos token.Pos) ast.Expr {
+func (f *cgoFile) makeDecayingASTType(typ C.CXType, pos token.Pos) ast.Expr {
 	// Strip typedefs, if any.
 	underlyingType := typ
 	if underlyingType.kind == C.CXType_Typedef {
@@ -417,15 +627,15 @@ func (p *cgoPackage) makeDecayingASTType(typ C.CXType, pos token.Pos) ast.Expr {
 		pointeeType := C.clang_getElementType(underlyingType)
 		return &ast.StarExpr{
 			Star: pos,
-			X:    p.makeASTType(pointeeType, pos),
+			X:    f.makeASTType(pointeeType, pos),
 		}
 	}
-	return p.makeASTType(typ, pos)
+	return f.makeASTType(typ, pos)
 }

 // makeASTType return the ast.Expr for the given libclang type. In other words,
 // it converts a libclang type to a type in the Go AST.
-func (p *cgoPackage) makeASTType(typ C.CXType, pos token.Pos) ast.Expr {
+func (f *cgoFile) makeASTType(typ C.CXType, pos token.Pos) ast.Expr {
 	var typeName string
 	switch typ.kind {
 	case C.CXType_Char_S, C.CXType_Char_U:
@@ -486,7 +696,7 @@ func (p *cgoPackage) makeASTType(typ C.CXType, pos token.Pos) ast.Expr {
 		}
 		return &ast.StarExpr{
 			Star: pos,
-			X:    p.makeASTType(pointeeType, pos),
+			X:    f.makeASTType(pointeeType, pos),
 		}
 	case C.CXType_ConstantArray:
 		return &ast.ArrayType{
@@ -496,7 +706,7 @@ func (p *cgoPackage) makeASTType(typ C.CXType, pos token.Pos) ast.Expr {
 				Kind:     token.INT,
 				Value:    strconv.FormatInt(int64(C.clang_getArraySize(typ)), 10),
 			},
-			Elt: p.makeASTType(C.clang_getElementType(typ), pos),
+			Elt: f.makeASTType(C.clang_getElementType(typ), pos),
 		}
 	case C.CXType_FunctionProto:
 		// Be compatible with gc, which uses the *[0]byte type for function
@@ -517,71 +727,21 @@ func (p *cgoPackage) makeASTType(typ C.CXType, pos token.Pos) ast.Expr {
 		}
 	case C.CXType_Typedef:
 		name := getString(C.clang_getTypedefName(typ))
-		if _, ok := p.typedefs[name]; !ok {
-			p.typedefs[name] = nil // don't recurse
-			c := C.tinygo_clang_getTypeDeclaration(typ)
-			underlyingType := C.tinygo_clang_getTypedefDeclUnderlyingType(c)
-			expr := p.makeASTType(underlyingType, pos)
-			if strings.HasPrefix(name, "_Cgo_") {
-				expr := expr.(*ast.Ident)
-				typeSize := C.clang_Type_getSizeOf(underlyingType)
-				switch expr.Name {
-				case "C.char":
-					if typeSize != 1 {
-						// This happens for some very special purpose architectures
-						// (DSPs etc.) that are not currently targeted.
-						// https://www.embecosm.com/2017/04/18/non-8-bit-char-support-in-clang-and-llvm/
-						p.addError(pos, fmt.Sprintf("unknown char width: %d", typeSize))
-					}
-					switch underlyingType.kind {
-					case C.CXType_Char_S:
-						expr.Name = "int8"
-					case C.CXType_Char_U:
-						expr.Name = "uint8"
-					}
-				case "C.schar", "C.short", "C.int", "C.long", "C.longlong":
-					switch typeSize {
-					case 1:
-						expr.Name = "int8"
-					case 2:
-						expr.Name = "int16"
-					case 4:
-						expr.Name = "int32"
-					case 8:
-						expr.Name = "int64"
-					}
-				case "C.uchar", "C.ushort", "C.uint", "C.ulong", "C.ulonglong":
-					switch typeSize {
-					case 1:
-						expr.Name = "uint8"
-					case 2:
-						expr.Name = "uint16"
-					case 4:
-						expr.Name = "uint32"
-					case 8:
-						expr.Name = "uint64"
-					}
-				}
-			}
-			p.typedefs[name] = &typedefInfo{
-				typeExpr: expr,
-				pos:      pos,
-			}
-		}
+		c := C.tinygo_clang_getTypeDeclaration(typ)
 		return &ast.Ident{
 			NamePos: pos,
-			Name:    "C." + name,
+			Name:    f.getASTDeclName(name, c, false),
 		}
 	case C.CXType_Elaborated:
 		underlying := C.clang_Type_getNamedType(typ)
 		switch underlying.kind {
 		case C.CXType_Record:
-			return p.makeASTType(underlying, pos)
+			return f.makeASTType(underlying, pos)
 		case C.CXType_Enum:
-			return p.makeASTType(underlying, pos)
+			return f.makeASTType(underlying, pos)
 		default:
 			typeKindSpelling := getString(C.clang_getTypeKindSpelling(underlying.kind))
-			p.addError(pos, fmt.Sprintf("unknown elaborated type (libclang type kind %s)", typeKindSpelling))
+			f.addError(pos, fmt.Sprintf("unknown elaborated type (libclang type kind %s)", typeKindSpelling))
 			typeName = "<unknown>"
 		}
 	case C.CXType_Record:
@@ -599,63 +759,46 @@ func (p *cgoPackage) makeASTType(typ C.CXType, pos token.Pos) ast.Expr {
 		}
 		if name == "" {
 			// Anonymous record, probably inside a typedef.
-			typeInfo := p.makeASTRecordType(cursor, pos)
-			if typeInfo.bitfields != nil || typeInfo.unionSize != 0 {
-				// This record is a union or is a struct with bitfields, so we
-				// have to declare it as a named type (for getters/setters to
-				// work).
-				p.anonStructNum++
-				cgoName := cgoRecordPrefix + strconv.Itoa(p.anonStructNum)
-				p.elaboratedTypes[cgoName] = typeInfo
-				return &ast.Ident{
-					NamePos: pos,
-					Name:    "C." + cgoName,
-				}
+			clangLocation := C.tinygo_clang_getCursorLocation(cursor)
+			var file C.CXFile
+			var line C.unsigned
+			var column C.unsigned
+			C.clang_getFileLocation(clangLocation, &file, &line, &column, nil)
+			location := token.Position{
+				Filename: getString(C.clang_getFileName(file)),
+				Line:     int(line),
+				Column:   int(column),
 			}
-			return typeInfo.typeExpr
+			if location.Filename == "" || location.Line == 0 {
+				// Not sure when this would happen, but protect from it anyway.
+				f.addError(pos, "could not find file/line information")
+			}
+			name = f.getUnnamedDeclName("_Ctype_"+cgoRecordPrefix+"__", location)
 		} else {
-			cgoName := cgoRecordPrefix + name
-			if _, ok := p.elaboratedTypes[cgoName]; !ok {
-				p.elaboratedTypes[cgoName] = nil // predeclare (to avoid endless recursion)
-				p.elaboratedTypes[cgoName] = p.makeASTRecordType(cursor, pos)
-			}
-			return &ast.Ident{
-				NamePos: pos,
-				Name:    "C." + cgoName,
-			}
+			name = cgoRecordPrefix + name
+		}
+		return &ast.Ident{
+			NamePos: pos,
+			Name:    f.getASTDeclName(name, cursor, false),
 		}
 	case C.CXType_Enum:
 		cursor := C.tinygo_clang_getTypeDeclaration(typ)
 		name := getString(C.tinygo_clang_getCursorSpelling(cursor))
-		underlying := C.tinygo_clang_getEnumDeclIntegerType(cursor)
 		if name == "" {
-			// anonymous enum
-			ref := storedRefs.Put(p)
-			defer storedRefs.Remove(ref)
-			C.tinygo_clang_visitChildren(cursor, C.CXCursorVisitor(C.tinygo_clang_enum_visitor), C.CXClientData(ref))
-			return p.makeASTType(underlying, pos)
+			name = f.getUnnamedDeclName("_Ctype_enum___", cursor)
 		} else {
-			// named enum
-			if _, ok := p.enums[name]; !ok {
-				ref := storedRefs.Put(p)
-				defer storedRefs.Remove(ref)
-				C.tinygo_clang_visitChildren(cursor, C.CXCursorVisitor(C.tinygo_clang_enum_visitor), C.CXClientData(ref))
-				p.enums[name] = enumInfo{
-					typeExpr: p.makeASTType(underlying, pos),
-					pos:      pos,
-				}
-			}
-			return &ast.Ident{
-				NamePos: pos,
-				Name:    "C.enum_" + name,
-			}
+			name = "enum_" + name
+		}
+		return &ast.Ident{
+			NamePos: pos,
+			Name:    f.getASTDeclName(name, cursor, false),
 		}
 	}
 	if typeName == "" {
 		// Report this as an error.
 		typeSpelling := getString(C.clang_getTypeSpelling(typ))
 		typeKindSpelling := getString(C.clang_getTypeKindSpelling(typ.kind))
-		p.addError(pos, fmt.Sprintf("unknown C type: %v (libclang type kind %s)", typeSpelling, typeKindSpelling))
+		f.addError(pos, fmt.Sprintf("unknown C type: %v (libclang type kind %s)", typeSpelling, typeKindSpelling))
 		typeName = "C.<unknown>"
 	}
 	return &ast.Ident{
@@ -664,9 +807,80 @@ func (p *cgoPackage) makeASTType(typ C.CXType, pos token.Pos) ast.Expr {
 	}
 }

+// getIntegerType returns an AST node that defines types such as C.int.
+func (p *cgoPackage) getIntegerType(name string, cursor clangCursor) *ast.TypeSpec {
+	pos := p.getCursorPosition(cursor)
+
+	// Find a Go type that matches the size and signedness of the given C type.
+	underlyingType := C.tinygo_clang_getTypedefDeclUnderlyingType(cursor)
+	var goName string
+	typeSize := C.clang_Type_getSizeOf(underlyingType)
+	switch name {
+	case "C.char":
+		if typeSize != 1 {
+			// This happens for some very special purpose architectures
+			// (DSPs etc.) that are not currently targeted.
+			// https://www.embecosm.com/2017/04/18/non-8-bit-char-support-in-clang-and-llvm/
+			p.addError(pos, fmt.Sprintf("unknown char width: %d", typeSize))
+		}
+		switch underlyingType.kind {
+		case C.CXType_Char_S:
+			goName = "int8"
+		case C.CXType_Char_U:
+			goName = "uint8"
+		}
+	case "C.schar", "C.short", "C.int", "C.long", "C.longlong":
+		switch typeSize {
+		case 1:
+			goName = "int8"
+		case 2:
+			goName = "int16"
+		case 4:
+			goName = "int32"
+		case 8:
+			goName = "int64"
+		}
+	case "C.uchar", "C.ushort", "C.uint", "C.ulong", "C.ulonglong":
+		switch typeSize {
+		case 1:
+			goName = "uint8"
+		case 2:
+			goName = "uint16"
+		case 4:
+			goName = "uint32"
+		case 8:
+			goName = "uint64"
+		}
+	}
+
+	if goName == "" { // should not happen
+		p.addError(pos, "internal error: did not find Go type for C type "+name)
+		goName = "int"
+	}
+
+	// Construct an *ast.TypeSpec for this type.
+	obj := &ast.Object{
+		Kind: ast.Typ,
+		Name: name,
+	}
+	spec := &ast.TypeSpec{
+		Name: &ast.Ident{
+			NamePos: pos,
+			Name:    name,
+			Obj:     obj,
+		},
+		Type: &ast.Ident{
+			NamePos: pos,
+			Name:    goName,
+		},
+	}
+	obj.Decl = spec
+	return spec
+}
+
 // makeASTRecordType parses a C record (struct or union) and translates it into
 // a Go struct type.
-func (p *cgoPackage) makeASTRecordType(cursor C.GoCXCursor, pos token.Pos) *elaboratedTypeInfo {
+func (f *cgoFile) makeASTRecordType(cursor C.GoCXCursor, pos token.Pos) *elaboratedTypeInfo {
 	fieldList := &ast.FieldList{
 		Opening: pos,
 		Closing: pos,
@@ -676,11 +890,11 @@ func (p *cgoPackage) makeASTRecordType(cursor C.GoCXCursor, pos token.Pos) *elab
 	bitfieldNum := 0
 	ref := storedRefs.Put(struct {
 		fieldList    *ast.FieldList
-		pkg          *cgoPackage
+		file         *cgoFile
 		inBitfield   *bool
 		bitfieldNum  *int
 		bitfieldList *[]bitfieldInfo
-	}{fieldList, p, &inBitfield, &bitfieldNum, &bitfieldList})
+	}{fieldList, f, &inBitfield, &bitfieldNum, &bitfieldList})
 	defer storedRefs.Remove(ref)
 	C.tinygo_clang_visitChildren(cursor, C.CXCursorVisitor(C.tinygo_clang_struct_visitor), C.CXClientData(ref))
 	renameFieldKeywords(fieldList)
@@ -709,13 +923,13 @@ func (p *cgoPackage) makeASTRecordType(cursor C.GoCXCursor, pos token.Pos) *elab
 		}
 		if bitfieldList != nil {
 			// This is valid C... but please don't do this.
-			p.addError(pos, "bitfield in a union is not supported")
+			f.addError(pos, "bitfield in a union is not supported")
 		}
 		typ := C.tinygo_clang_getCursorType(cursor)
 		alignInBytes := int64(C.clang_Type_getAlignOf(typ))
 		sizeInBytes := int64(C.clang_Type_getSizeOf(typ))
 		if sizeInBytes == 0 {
-			p.addError(pos, "zero-length union is not supported")
+			f.addError(pos, "zero-length union is not supported")
 		}
 		typeInfo.unionSize = sizeInBytes
 		typeInfo.unionAlign = alignInBytes
@@ -723,7 +937,7 @@ func (p *cgoPackage) makeASTRecordType(cursor C.GoCXCursor, pos token.Pos) *elab
 	default:
 		cursorKind := C.tinygo_clang_getCursorKind(cursor)
 		cursorKindSpelling := getString(C.clang_getCursorKindSpelling(cursorKind))
-		p.addError(pos, fmt.Sprintf("expected StructDecl or UnionDecl, not %s", cursorKindSpelling))
+		f.addError(pos, fmt.Sprintf("expected StructDecl or UnionDecl, not %s", cursorKindSpelling))
 		return &elaboratedTypeInfo{
 			typeExpr: &ast.StructType{
 				Struct: pos,
@@ -737,17 +951,17 @@ func (p *cgoPackage) makeASTRecordType(cursor C.GoCXCursor, pos token.Pos) *elab
 func tinygo_clang_struct_visitor(c, parent C.GoCXCursor, client_data C.CXClientData) C.int {
 	passed := storedRefs.Get(unsafe.Pointer(client_data)).(struct {
 		fieldList    *ast.FieldList
-		pkg          *cgoPackage
+		file         *cgoFile
 		inBitfield   *bool
 		bitfieldNum  *int
 		bitfieldList *[]bitfieldInfo
 	})
 	fieldList := passed.fieldList
-	p := passed.pkg
+	f := passed.file
 	inBitfield := passed.inBitfield
 	bitfieldNum := passed.bitfieldNum
 	bitfieldList := passed.bitfieldList
-	pos := p.getCursorPosition(c)
+	pos := f.getCursorPosition(c)
 	switch cursorKind := C.tinygo_clang_getCursorKind(c); cursorKind {
 	case C.CXCursor_FieldDecl:
 		// Expected. This is a regular field.
@@ -756,7 +970,7 @@ func tinygo_clang_struct_visitor(c, parent C.GoCXCursor, client_data C.CXClientD
 		return C.CXChildVisit_Continue
 	default:
 		cursorKindSpelling := getString(C.clang_getCursorKindSpelling(cursorKind))
-		p.addError(pos, fmt.Sprintf("expected FieldDecl in struct or union, not %s", cursorKindSpelling))
+		f.addError(pos, fmt.Sprintf("expected FieldDecl in struct or union, not %s", cursorKindSpelling))
 		return C.CXChildVisit_Continue
 	}
 	name := getString(C.tinygo_clang_getCursorSpelling(c))
@@ -767,14 +981,14 @@ func tinygo_clang_struct_visitor(c, parent C.GoCXCursor, client_data C.CXClientD
 	}
 	typ := C.tinygo_clang_getCursorType(c)
 	field := &ast.Field{
-		Type: p.makeASTType(typ, p.getCursorPosition(c)),
+		Type: f.makeASTType(typ, f.getCursorPosition(c)),
 	}
 	offsetof := int64(C.clang_Type_getOffsetOf(C.tinygo_clang_getCursorType(parent), C.CString(name)))
 	alignOf := int64(C.clang_Type_getAlignOf(typ) * 8)
 	bitfieldOffset := offsetof % alignOf
 	if bitfieldOffset != 0 {
 		if C.tinygo_clang_Cursor_isBitField(c) != 1 {
-			p.addError(pos, "expected a bitfield")
+			f.addError(pos, "expected a bitfield")
 			return C.CXChildVisit_Continue
 		}
 		if !*inBitfield {
@@ -821,23 +1035,6 @@ func tinygo_clang_struct_visitor(c, parent C.GoCXCursor, client_data C.CXClientD
 	return C.CXChildVisit_Continue
 }

-//export tinygo_clang_enum_visitor
-func tinygo_clang_enum_visitor(c, parent C.GoCXCursor, client_data C.CXClientData) C.int {
-	p := storedRefs.Get(unsafe.Pointer(client_data)).(*cgoPackage)
-	name := getString(C.tinygo_clang_getCursorSpelling(c))
-	pos := p.getCursorPosition(c)
-	value := C.tinygo_clang_getEnumConstantDeclValue(c)
-	p.constants[name] = constantInfo{
-		expr: &ast.BasicLit{
-			ValuePos: pos,
-			Kind:     token.INT,
-			Value:    strconv.FormatInt(int64(value), 10),
-		},
-		pos: pos,
-	}
-	return C.CXChildVisit_Continue
-}
-
 //export tinygo_clang_inclusion_visitor
 func tinygo_clang_inclusion_visitor(includedFile C.CXFile, inclusionStack *C.CXSourceLocation, includeLen C.unsigned, clientData C.CXClientData) {
 	callback := storedRefs.Get(unsafe.Pointer(clientData)).(func(C.CXFile))
@@ -1,16 +0,0 @@
-//go:build !byollvm && llvm11
-// +build !byollvm,llvm11
-
-package cgo
-
-/*
-#cgo linux        CFLAGS:  -I/usr/lib/llvm-11/include
-#cgo darwin amd64 CFLAGS:  -I/usr/local/opt/llvm@11/include
-#cgo darwin arm64 CFLAGS:  -I/opt/homebrew/opt/llvm@11/include
-#cgo freebsd      CFLAGS:  -I/usr/local/llvm11/include
-#cgo linux        LDFLAGS: -L/usr/lib/llvm-11/lib -lclang
-#cgo darwin amd64 LDFLAGS: -L/usr/local/opt/llvm@11/lib -lclang -lffi
-#cgo darwin arm64 LDFLAGS: -L/opt/homebrew/opt/llvm@11/lib -lclang -lffi
-#cgo freebsd      LDFLAGS: -L/usr/local/llvm11/lib -lclang
-*/
-import "C"
@@ -1,16 +0,0 @@
-//go:build !byollvm && llvm12
-// +build !byollvm,llvm12
-
-package cgo
-
-/*
-#cgo linux        CFLAGS:  -I/usr/lib/llvm-12/include
-#cgo darwin amd64 CFLAGS:  -I/usr/local/opt/llvm@12/include
-#cgo darwin arm64 CFLAGS:  -I/opt/homebrew/opt/llvm@12/include
-#cgo freebsd      CFLAGS:  -I/usr/local/llvm12/include
-#cgo linux        LDFLAGS: -L/usr/lib/llvm-12/lib -lclang
-#cgo darwin amd64 LDFLAGS: -L/usr/local/opt/llvm@12/lib -lclang -lffi
-#cgo darwin arm64 LDFLAGS: -L/opt/homebrew/opt/llvm@12/lib -lclang -lffi
-#cgo freebsd      LDFLAGS: -L/usr/local/llvm12/lib -lclang
-*/
-import "C"
@@ -1,16 +0,0 @@
-//go:build !byollvm && !llvm11 && !llvm12
-// +build !byollvm,!llvm11,!llvm12
-
-package cgo
-
-/*
-#cgo linux        CFLAGS:  -I/usr/lib/llvm-13/include
-#cgo darwin amd64 CFLAGS:  -I/usr/local/opt/llvm@13/include
-#cgo darwin arm64 CFLAGS:  -I/opt/homebrew/opt/llvm@13/include
-#cgo freebsd      CFLAGS:  -I/usr/local/llvm13/include
-#cgo linux        LDFLAGS: -L/usr/lib/llvm-13/lib -lclang
-#cgo darwin amd64 LDFLAGS: -L/usr/local/opt/llvm@13/lib -lclang -lffi
-#cgo darwin arm64 LDFLAGS: -L/opt/homebrew/opt/llvm@13/lib -lclang -lffi
-#cgo freebsd      LDFLAGS: -L/usr/local/llvm13/lib -lclang
-*/
-import "C"
@@ -0,0 +1,16 @@
+//go:build !byollvm
+// +build !byollvm
+
+package cgo
+
+/*
+#cgo linux        CFLAGS:  -I/usr/lib/llvm-14/include
+#cgo darwin,amd64 CFLAGS:  -I/usr/local/opt/llvm@14/include
+#cgo darwin,arm64 CFLAGS:  -I/opt/homebrew/opt/llvm@14/include
+#cgo freebsd      CFLAGS:  -I/usr/local/llvm14/include
+#cgo linux        LDFLAGS: -L/usr/lib/llvm-14/lib -lclang
+#cgo darwin,amd64 LDFLAGS: -L/usr/local/opt/llvm@14/lib -lclang -lffi
+#cgo darwin,arm64 LDFLAGS: -L/opt/homebrew/opt/llvm@14/lib -lclang -lffi
+#cgo freebsd      LDFLAGS: -L/usr/local/llvm14/lib -lclang
+*/
+import "C"
@@ -3,7 +3,7 @@
 // are slightly different from the ones defined in libclang.go, but they
 // should be ABI compatible.

-#include <clang-c/Index.h> // if this fails, install libclang-11-dev
+#include <clang-c/Index.h> // If this fails, libclang headers aren't available. Please take a look here: https://tinygo.org/docs/guides/build/

 CXCursor tinygo_clang_getTranslationUnitCursor(CXTranslationUnit tu) {
 	return clang_getTranslationUnitCursor(tu);
@@ -24,23 +24,16 @@ 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
-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
+type (
+	C.char      uint8
+	C.schar     int8
+	C.uchar     uint8
+	C.short     int16
+	C.ushort    uint16
+	C.int       int32
+	C.uint      uint32
+	C.long      int32
+	C.ulong     uint32
+	C.longlong  int64
+	C.ulonglong uint64
+)
@@ -24,26 +24,19 @@ 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
+type (
+	C.char      uint8
+	C.schar     int8
+	C.uchar     uint8
+	C.short     int16
+	C.ushort    uint16
+	C.int       int32
+	C.uint      uint32
+	C.long      int32
+	C.ulong     uint32
+	C.longlong  int64
+	C.ulonglong uint64
+)

-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
+const C.foo = 3
+const C.bar = C.foo
@@ -27,7 +27,7 @@ import "C"
 //line errors.go:100
 var (
 	// constant too large
-	_ C.uint8_t = 2 << 10
+	_ C.char = 2 << 10

 	// z member does not exist
 	_ C.point_t = C.point_t{z: 3}
@@ -6,7 +6,7 @@
 //     testdata/errors.go:19:26: unexpected token ), expected end of expression

 // Type checking errors after CGo processing:
-//     testdata/errors.go:102: cannot use 2 << 10 (untyped int constant 2048) as uint8 value in variable declaration (overflows)
+//     testdata/errors.go:102: cannot use 2 << 10 (untyped int constant 2048) as C.char value in variable declaration (overflows)
 //     testdata/errors.go:105: unknown field z in struct literal
 //     testdata/errors.go:108: undeclared name: C.SOME_CONST_1
 //     testdata/errors.go:110: cannot use C.SOME_CONST_3 (untyped int constant 1234) as byte value in variable declaration (overflows)
@@ -38,29 +38,23 @@ 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
-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
-type C.point_t = struct {
+type (
+	C.char      uint8
+	C.schar     int8
+	C.uchar     uint8
+	C.short     int16
+	C.ushort    uint16
+	C.int       int32
+	C.uint      uint32
+	C.long      int32
+	C.ulong     uint32
+	C.longlong  int64
+	C.ulonglong uint64
+)
+type C._Ctype_struct___0 struct {
 	x C.int
 	y C.int
 }
+type C.point_t = C._Ctype_struct___0
+
+const C.SOME_CONST_3 = 1234
@@ -29,26 +29,19 @@ func C.GoBytes(ptr unsafe.Pointer, length C.int) []byte {
 	return C.__GoBytes(ptr, uintptr(length))
 }

+type (
+	C.char      uint8
+	C.schar     int8
+	C.uchar     uint8
+	C.short     int16
+	C.ushort    uint16
+	C.int       int32
+	C.uint      uint32
+	C.long      int32
+	C.ulong     uint32
+	C.longlong  int64
+	C.ulonglong uint64
+)
+
 const C.BAR = 3
 const C.FOO_H = 1
-
-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
@@ -24,41 +24,36 @@ func C.GoBytes(ptr unsafe.Pointer, length C.int) []byte {
 	return C.__GoBytes(ptr, uintptr(length))
 }

+type (
+	C.char      uint8
+	C.schar     int8
+	C.uchar     uint8
+	C.short     int16
+	C.ushort    uint16
+	C.int       int32
+	C.uint      uint32
+	C.long      int32
+	C.ulong     uint32
+	C.longlong  int64
+	C.ulonglong uint64
+)
+
 //export foo
 func C.foo(a C.int, b C.int) C.int

+var C.foo$funcaddr unsafe.Pointer
+
 //export variadic0
 //go:variadic
 func C.variadic0()

+var C.variadic0$funcaddr unsafe.Pointer
+
 //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
@@ -24,132 +24,126 @@ func C.GoBytes(ptr unsafe.Pointer, length C.int) []byte {
 	return C.__GoBytes(ptr, uintptr(length))
 }

-const C.option2A = 20
-const C.optionA = 0
-const C.optionB = 1
-const C.optionC = -5
-const C.optionD = -4
-const C.optionE = 10
-const C.optionF = 11
-const C.optionG = 12
-const C.unused1 = 5
-
-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
-type C.bitfield_t = C.struct_4
-type C.myIntArray = [10]C.int
+type (
+	C.char      uint8
+	C.schar     int8
+	C.uchar     uint8
+	C.short     int16
+	C.ushort    uint16
+	C.int       int32
+	C.uint      uint32
+	C.long      int32
+	C.ulong     uint32
+	C.longlong  int64
+	C.ulonglong uint64
+)
 type C.myint = C.int
-type C.option2_t = C.uint
-type C.option_t = C.enum_option
-type C.point2d_t = struct {
+type C._Ctype_struct___0 struct {
 	x C.int
 	y C.int
 }
-type C.point3d_t = C.struct_point3d
-type C.struct_nested_t = struct {
-	begin C.point2d_t
-	end   C.point2d_t
-	tag   C.int
-
-	coord C.union_2
-}
-type C.types_t = struct {
-	f   float32
-	d   float64
-	ptr *C.int
-}
-type C.union1_t = struct{ i C.int }
-type C.union2d_t = C.union_union2d
-type C.union3_t = C.union_1
-type C.union_nested_t = C.union_3
-type C.unionarray_t = struct{ arr [10]C.uchar }
-
-func (s *C.struct_4) bitfield_a() C.uchar { return s.__bitfield_1 & 0x1f }
-func (s *C.struct_4) set_bitfield_a(value C.uchar) {
-	s.__bitfield_1 = s.__bitfield_1&^0x1f | value&0x1f<<0
-}
-func (s *C.struct_4) bitfield_b() C.uchar {
-	return s.__bitfield_1 >> 5 & 0x1
-}
-func (s *C.struct_4) set_bitfield_b(value C.uchar) {
-	s.__bitfield_1 = s.__bitfield_1&^0x20 | value&0x1<<5
-}
-func (s *C.struct_4) bitfield_c() C.uchar {
-	return s.__bitfield_1 >> 6
-}
-func (s *C.struct_4) set_bitfield_c(value C.uchar,
-
-) { s.__bitfield_1 = s.__bitfield_1&0x3f | value<<6 }
-
-type C.struct_4 struct {
-	start        C.uchar
-	__bitfield_1 C.uchar
-
-	d C.uchar
-	e C.uchar
-}
+type C.point2d_t = C._Ctype_struct___0
 type C.struct_point3d struct {
 	x C.int
 	y C.int
 	z C.int
 }
+type C.point3d_t = C.struct_point3d
 type C.struct_type1 struct {
 	_type   C.int
 	__type  C.int
 	___type C.int
 }
 type C.struct_type2 struct{ _type C.int }
+type C._Ctype_union___1 struct{ i C.int }
+type C.union1_t = C._Ctype_union___1
+type C._Ctype_union___2 struct{ $union uint64 }

-func (union *C.union_1) unionfield_i() *C.int   { return (*C.int)(unsafe.Pointer(&union.$union)) }
-func (union *C.union_1) unionfield_d() *float64 { return (*float64)(unsafe.Pointer(&union.$union)) }
-func (union *C.union_1) unionfield_s() *C.short { return (*C.short)(unsafe.Pointer(&union.$union)) }
-
-type C.union_1 struct{ $union uint64 }
-
-func (union *C.union_2) unionfield_area() *C.point2d_t {
-	return (*C.point2d_t)(unsafe.Pointer(&union.$union))
+func (union *C._Ctype_union___2) unionfield_i() *C.int {
+	return (*C.int)(unsafe.Pointer(&union.$union))
 }
-func (union *C.union_2) unionfield_solid() *C.point3d_t {
-	return (*C.point3d_t)(unsafe.Pointer(&union.$union))
+func (union *C._Ctype_union___2) unionfield_d() *float64 {
+	return (*float64)(unsafe.Pointer(&union.$union))
+}
+func (union *C._Ctype_union___2) unionfield_s() *C.short {
+	return (*C.short)(unsafe.Pointer(&union.$union))
 }

-type C.union_2 struct{ $union [3]uint32 }
-
-func (union *C.union_3) unionfield_point() *C.point3d_t {
-	return (*C.point3d_t)(unsafe.Pointer(&union.$union))
-}
-func (union *C.union_3) unionfield_array() *C.unionarray_t {
-	return (*C.unionarray_t)(unsafe.Pointer(&union.$union))
-}
-func (union *C.union_3) unionfield_thing() *C.union3_t {
-	return (*C.union3_t)(unsafe.Pointer(&union.$union))
-}
-
-type C.union_3 struct{ $union [2]uint64 }
+type C.union3_t = C._Ctype_union___2
+type C.union_union2d struct{ $union [2]uint64 }

 func (union *C.union_union2d) unionfield_i() *C.int { return (*C.int)(unsafe.Pointer(&union.$union)) }
 func (union *C.union_union2d) unionfield_d() *[2]float64 {
 	return (*[2]float64)(unsafe.Pointer(&union.$union))
 }

-type C.union_union2d struct{ $union [2]uint64 }
-type C.enum_option C.int
-type C.enum_unused C.uint
+type C.union2d_t = C.union_union2d
+type C._Ctype_union___3 struct{ arr [10]C.uchar }
+type C.unionarray_t = C._Ctype_union___3
+type C._Ctype_union___5 struct{ $union [3]uint32 }
+
+func (union *C._Ctype_union___5) unionfield_area() *C.point2d_t {
+	return (*C.point2d_t)(unsafe.Pointer(&union.$union))
+}
+func (union *C._Ctype_union___5) unionfield_solid() *C.point3d_t {
+	return (*C.point3d_t)(unsafe.Pointer(&union.$union))
+}
+
+type C._Ctype_struct___4 struct {
+	begin C.point2d_t
+	end   C.point2d_t
+	tag   C.int
+
+	coord C._Ctype_union___5
+}
+type C.struct_nested_t = C._Ctype_struct___4
+type C._Ctype_union___6 struct{ $union [2]uint64 }
+
+func (union *C._Ctype_union___6) unionfield_point() *C.point3d_t {
+	return (*C.point3d_t)(unsafe.Pointer(&union.$union))
+}
+func (union *C._Ctype_union___6) unionfield_array() *C.unionarray_t {
+	return (*C.unionarray_t)(unsafe.Pointer(&union.$union))
+}
+func (union *C._Ctype_union___6) unionfield_thing() *C.union3_t {
+	return (*C.union3_t)(unsafe.Pointer(&union.$union))
+}
+
+type C.union_nested_t = C._Ctype_union___6
+type C.enum_option = C.int
+type C.option_t = C.enum_option
+type C._Ctype_enum___7 = C.uint
+type C.option2_t = C._Ctype_enum___7
+type C._Ctype_struct___8 struct {
+	f   float32
+	d   float64
+	ptr *C.int
+}
+type C.types_t = C._Ctype_struct___8
+type C.myIntArray = [10]C.int
+type C._Ctype_struct___9 struct {
+	start        C.uchar
+	__bitfield_1 C.uchar
+
+	d C.uchar
+	e C.uchar
+}
+
+func (s *C._Ctype_struct___9) bitfield_a() C.uchar { return s.__bitfield_1 & 0x1f }
+func (s *C._Ctype_struct___9) set_bitfield_a(value C.uchar) {
+	s.__bitfield_1 = s.__bitfield_1&^0x1f | value&0x1f<<0
+}
+func (s *C._Ctype_struct___9) bitfield_b() C.uchar {
+	return s.__bitfield_1 >> 5 & 0x1
+}
+func (s *C._Ctype_struct___9) set_bitfield_b(value C.uchar) {
+	s.__bitfield_1 = s.__bitfield_1&^0x20 | value&0x1<<5
+}
+func (s *C._Ctype_struct___9) bitfield_c() C.uchar {
+	return s.__bitfield_1 >> 6
+}
+func (s *C._Ctype_struct___9) set_bitfield_c(value C.uchar,
+
+) { s.__bitfield_1 = s.__bitfield_1&0x3f | value<<6 }
+
+type C.bitfield_t = C._Ctype_struct___9
@@ -10,6 +10,7 @@ import (
 	"regexp"
 	"strings"

+	"github.com/google/shlex"
 	"github.com/tinygo-org/tinygo/goenv"
 )

@@ -72,9 +73,7 @@ func (c *Config) BuildTags() []string {
 	for i := 1; i <= c.GoMinorVersion; i++ {
 		tags = append(tags, fmt.Sprintf("go1.%d", i))
 	}
-	if extraTags := strings.Fields(c.Options.Tags); len(extraTags) != 0 {
-		tags = append(tags, extraTags...)
-	}
+	tags = append(tags, c.Options.Tags...)
 	return tags
 }

@@ -176,6 +175,25 @@ func (c *Config) AutomaticStackSize() bool {
 	return false
 }

+// UseThinLTO returns whether ThinLTO should be used for the given target. Some
+// targets (such as wasm) are not yet supported.
+// We should try and remove as many exceptions as possible in the future, so
+// that this optimization can be applied in more places.
+func (c *Config) UseThinLTO() bool {
+	parts := strings.Split(c.Triple(), "-")
+	if parts[0] == "wasm32" {
+		// wasm-ld doesn't seem to support ThinLTO yet.
+		return false
+	}
+	if parts[0] == "avr" || parts[0] == "xtensa" {
+		// These use external (GNU) linkers which might perhaps support ThinLTO
+		// through a plugin, but it's too much hassle to set up.
+		return false
+	}
+	// Other architectures support ThinLTO.
+	return true
+}
+
 // RP2040BootPatch returns whether the RP2040 boot patch should be applied that
 // calculates and patches in the checksum for the 2nd stage bootloader.
 func (c *Config) RP2040BootPatch() bool {
@@ -217,6 +235,29 @@ func (c *Config) LibcPath(name string) (path string, precompiled bool) {
 	return filepath.Join(goenv.Get("GOCACHE"), name+"-"+archname), false
 }

+// DefaultBinaryExtension returns the default extension for binaries, such as
+// .exe, .wasm, or no extension (depending on the target).
+func (c *Config) DefaultBinaryExtension() string {
+	parts := strings.Split(c.Triple(), "-")
+	if parts[0] == "wasm32" {
+		// WebAssembly files always have the .wasm file extension.
+		return ".wasm"
+	}
+	if len(parts) >= 3 && parts[2] == "windows" {
+		// Windows uses .exe.
+		return ".exe"
+	}
+	if len(parts) >= 3 && parts[2] == "unknown" {
+		// There appears to be a convention to use the .elf file extension for
+		// ELF files intended for microcontrollers. I'm not aware of the origin
+		// of this, it's just something that is used by many projects.
+		// I think it's a good tradition, so let's keep it.
+		return ".elf"
+	}
+	// Linux, MacOS, etc, don't use a file extension. Use it as a fallback.
+	return ""
+}
+
 // CFlags returns the flags to pass to the C compiler. This is necessary for CGo
 // preprocessing.
 func (c *Config) CFlags() []string {
@@ -225,12 +266,18 @@ func (c *Config) CFlags() []string {
 		cflags = append(cflags, strings.ReplaceAll(flag, "{root}", goenv.Get("TINYGOROOT")))
 	}
 	switch c.Target.Libc {
+	case "darwin-libSystem":
+		root := goenv.Get("TINYGOROOT")
+		cflags = append(cflags,
+			"--sysroot="+filepath.Join(root, "lib/macos-minimal-sdk/src"),
+		)
 	case "picolibc":
 		root := goenv.Get("TINYGOROOT")
 		picolibcDir := filepath.Join(root, "lib", "picolibc", "newlib", "libc")
 		path, _ := c.LibcPath("picolibc")
 		cflags = append(cflags,
 			"--sysroot="+path,
+			"-isystem", filepath.Join(path, "include"), // necessary for Xtensa
 			"-isystem", filepath.Join(picolibcDir, "include"),
 			"-isystem", filepath.Join(picolibcDir, "tinystdio"),
 		)
@@ -337,6 +384,13 @@ func (c *Config) BinaryFormat(ext string) string {
 			return c.Target.BinaryFormat
 		}
 		return "bin"
+	case ".img":
+		// Image file. Only defined for the ESP32 at the moment, where it is a
+		// full (runnable) image that can be used in the Espressif QEMU fork.
+		if c.Target.BinaryFormat != "" {
+			return c.Target.BinaryFormat + "-img"
+		}
+		return "bin"
 	case ".hex":
 		// Similar to bin, but includes the start address and is thus usually a
 		// better format.
@@ -386,13 +440,13 @@ func (c *Config) OpenOCDConfiguration() (args []string, err error) {
 	if openocdInterface == "" {
 		return nil, errors.New("OpenOCD programmer not set")
 	}
-	if !regexp.MustCompile("^[\\p{L}0-9_-]+$").MatchString(openocdInterface) {
+	if !regexp.MustCompile(`^[\p{L}0-9_-]+$`).MatchString(openocdInterface) {
 		return nil, fmt.Errorf("OpenOCD programmer has an invalid name: %#v", openocdInterface)
 	}
 	if c.Target.OpenOCDTarget == "" {
 		return nil, errors.New("OpenOCD chip not set")
 	}
-	if !regexp.MustCompile("^[\\p{L}0-9_-]+$").MatchString(c.Target.OpenOCDTarget) {
+	if !regexp.MustCompile(`^[\p{L}0-9_-]+$`).MatchString(c.Target.OpenOCDTarget) {
 		return nil, fmt.Errorf("OpenOCD target has an invalid name: %#v", c.Target.OpenOCDTarget)
 	}
 	if c.Target.OpenOCDTransport != "" && c.Target.OpenOCDTransport != "swd" {
@@ -403,7 +457,14 @@ func (c *Config) OpenOCDConfiguration() (args []string, err error) {
 		args = append(args, "-c", cmd)
 	}
 	if c.Target.OpenOCDTransport != "" {
-		args = append(args, "-c", "transport select "+c.Target.OpenOCDTransport)
+		transport := c.Target.OpenOCDTransport
+		if transport == "swd" {
+			switch openocdInterface {
+			case "stlink-dap":
+				transport = "dapdirect_swd"
+			}
+		}
+		args = append(args, "-c", "transport select "+transport)
 	}
 	args = append(args, "-f", "target/"+c.Target.OpenOCDTarget+".cfg")
 	return args, nil
@@ -437,13 +498,43 @@ 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")))
+// EmulatorName is a shorthand to get the command for this emulator, something
+// like qemu-system-arm or simavr.
+func (c *Config) EmulatorName() string {
+	parts := strings.SplitN(c.Target.Emulator, " ", 2)
+	if len(parts) > 1 {
+		return parts[0]
 	}
-	return emulator
+	return ""
+}
+
+// EmulatorFormat returns the binary format for the emulator and the associated
+// file extension. An empty string means to pass directly whatever the linker
+// produces directly without conversion (usually ELF format).
+func (c *Config) EmulatorFormat() (format, fileExt string) {
+	switch {
+	case strings.Contains(c.Target.Emulator, "{img}"):
+		return "img", ".img"
+	default:
+		return "", ""
+	}
+}
+
+// Emulator returns a ready-to-run command to run the given binary in an
+// emulator. Give it the format (returned by EmulatorFormat()) and the path to
+// the compiled binary.
+func (c *Config) Emulator(format, binary string) ([]string, error) {
+	parts, err := shlex.Split(c.Target.Emulator)
+	if err != nil {
+		return nil, fmt.Errorf("could not parse emulator command: %w", err)
+	}
+	var emulator []string
+	for _, s := range parts {
+		s = strings.ReplaceAll(s, "{root}", goenv.Get("TINYGOROOT"))
+		s = strings.ReplaceAll(s, "{"+format+"}", binary)
+		emulator = append(emulator, s)
+	}
+	return emulator, nil
 }

 type TestConfig struct {
@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"regexp"
 	"strings"
+	"time"
 )

 var (
@@ -28,16 +29,18 @@ type Options struct {
 	PanicStrategy   string
 	Scheduler       string
 	Serial          string
+	Work            bool // -work flag to print temporary build directory
+	InterpTimeout   time.Duration
 	PrintIR         bool
 	DumpSSA         bool
 	VerifyIR        bool
-	PrintCommands   func(cmd string, args ...string)
-	Semaphore       chan struct{} // -p flag controls cap
+	PrintCommands   func(cmd string, args ...string) `json:"-"`
+	Semaphore       chan struct{}                    `json:"-"` // -p flag controls cap
 	Debug           bool
 	PrintSizes      string
 	PrintAllocs     *regexp.Regexp // regexp string
 	PrintStacks     bool
-	Tags            string
+	Tags            []string
 	WasmAbi         string
 	GlobalValues    map[string]map[string]string // map[pkgpath]map[varname]value
 	TestConfig      TestConfig
@@ -45,6 +48,7 @@ type Options struct {
 	OpenOCDCommands []string
 	LLVMFeatures    string
 	Directory       string
+	PrintJSON       bool
 }

 // Verify performs a validation on the given options, raising an error if options are not valid.
@@ -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.
@@ -44,8 +42,8 @@ type TargetSpec struct {
 	LDFlags          []string `json:"ldflags"`
 	LinkerScript     string   `json:"linkerscript"`
 	ExtraFiles       []string `json:"extra-files"`
-	RP2040BootPatch  *bool    `json:"rp2040-boot-patch"`        // Patch RP2040 2nd stage bootloader checksum
-	Emulator         []string `json:"emulator" override:"copy"` // inherited Emulator must not be append
+	RP2040BootPatch  *bool    `json:"rp2040-boot-patch"` // Patch RP2040 2nd stage bootloader checksum
+	Emulator         string   `json:"emulator"`
 	FlashCommand     string   `json:"flash-command"`
 	GDB              []string `json:"gdb"`
 	PortReset        string   `json:"flash-1200-bps-reset"`
@@ -59,6 +57,7 @@ type TargetSpec struct {
 	OpenOCDTarget    string   `json:"openocd-target"`
 	OpenOCDTransport string   `json:"openocd-transport"`
 	OpenOCDCommands  []string `json:"openocd-commands"`
+	OpenOCDVerify    *bool    `json:"openocd-verify"` // enable verify when flashing with openocd
 	JLinkDevice      string   `json:"jlink-device"`
 	CodeModel        string   `json:"code-model"`
 	RelocationModel  string   `json:"relocation-model"`
@@ -66,7 +65,7 @@ type TargetSpec struct {
 }

 // overrideProperties overrides all properties that are set in child into itself using reflection.
-func (spec *TargetSpec) overrideProperties(child *TargetSpec) {
+func (spec *TargetSpec) overrideProperties(child *TargetSpec) error {
 	specType := reflect.TypeOf(spec).Elem()
 	specValue := reflect.ValueOf(spec).Elem()
 	childValue := reflect.ValueOf(child).Elem()
@@ -89,23 +88,22 @@ func (spec *TargetSpec) overrideProperties(child *TargetSpec) {
 			if !src.IsNil() {
 				dst.Set(src)
 			}
-		case reflect.Slice: // for slices...
-			if src.Len() > 0 { // ... if not empty ...
-				switch tag := field.Tag.Get("override"); tag {
-				case "copy":
-					// copy the field of child to spec
-					dst.Set(src)
-				case "append", "":
-					// or append the field of child to spec
-					dst.Set(reflect.AppendSlice(dst, src))
-				default:
-					panic("override mode must be 'copy' or 'append' (default). I don't know how to '" + tag + "'.")
+		case reflect.Slice: // for slices, append the field and check for duplicates
+			dst.Set(reflect.AppendSlice(dst, src))
+			for i := 0; i < dst.Len(); i++ {
+				v := dst.Index(i).String()
+				for j := i + 1; j < dst.Len(); j++ {
+					w := dst.Index(j).String()
+					if v == w {
+						return fmt.Errorf("duplicate value '%s' in field %s", v, field.Name)
+					}
 				}
 			}
 		default:
-			panic("unknown field type : " + kind.String())
+			return fmt.Errorf("unknown field type: %s", kind)
 		}
 	}
+	return nil
 }

 // load reads a target specification from the JSON in the given io.Reader. It
@@ -120,10 +118,10 @@ func (spec *TargetSpec) load(r io.Reader) error {
 }

 // loadFromGivenStr loads the TargetSpec from the given string that could be:
-// - targets/ directory inside the compiler sources
-// - a relative or absolute path to custom (project specific) target specification .json file;
-//   the Inherits[] could contain the files from target folder (ex. stm32f4disco)
-//   as well as path to custom files (ex. myAwesomeProject.json)
+//   - targets/ directory inside the compiler sources
+//   - a relative or absolute path to custom (project specific) target specification .json file;
+//     the Inherits[] could contain the files from target folder (ex. stm32f4disco)
+//     as well as path to custom files (ex. myAwesomeProject.json)
 func (spec *TargetSpec) loadFromGivenStr(str string) error {
 	path := ""
 	if strings.HasSuffix(str, ".json") {
@@ -153,11 +151,17 @@ func (spec *TargetSpec) resolveInherits() error {
 		if err != nil {
 			return err
 		}
-		newSpec.overrideProperties(subtarget)
+		err = newSpec.overrideProperties(subtarget)
+		if err != nil {
+			return err
+		}
 	}

 	// When all properties are loaded, make sure they are properly inherited.
-	newSpec.overrideProperties(spec)
+	err := newSpec.overrideProperties(spec)
+	if err != nil {
+		return err
+	}
 	*spec = *newSpec

 	return nil
@@ -205,11 +209,10 @@ func LoadTarget(options *Options) (*TargetSpec, error) {
 		// triples for historical reasons) have the form:
 		//   arch-vendor-os-environment
 		target := llvmarch + "-unknown-" + llvmos
-		if options.GOARCH == "arm" {
-			target += "-gnueabihf"
-		}
 		if options.GOOS == "windows" {
 			target += "-gnu"
+		} else if options.GOARCH == "arm" {
+			target += "-gnueabihf"
 		}
 		return defaultTarget(options.GOOS, options.GOARCH, target)
 	}
@@ -225,7 +228,7 @@ func LoadTarget(options *Options) (*TargetSpec, error) {
 	// it includes all parents as specified in the "inherits" key.
 	err = spec.resolveInherits()
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("%s : %w", options.Target, err)
 	}

 	if spec.Scheduler == "asyncify" {
@@ -258,7 +261,7 @@ 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")
+		spec.CFlags = append(spec.CFlags, "-fno-unwind-tables", "-fno-asynchronous-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"
@@ -272,8 +275,16 @@ func defaultTarget(goos, goarch, triple string) (*TargetSpec, error) {
 		spec.Features = "+neon"
 	}
 	if goos == "darwin" {
-		spec.CFlags = append(spec.CFlags, "-isysroot", "/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk")
-		spec.LDFlags = append(spec.LDFlags, "-Wl,-dead_strip")
+		spec.Linker = "ld.lld"
+		spec.Libc = "darwin-libSystem"
+		arch := strings.Split(triple, "-")[0]
+		platformVersion := strings.TrimPrefix(strings.Split(triple, "-")[2], "macosx")
+		spec.LDFlags = append(spec.LDFlags,
+			"-flavor", "darwin",
+			"-dead_strip",
+			"-arch", arch,
+			"-platform_version", "macos", platformVersion, platformVersion,
+		)
 	} else if goos == "linux" {
 		spec.Linker = "ld.lld"
 		spec.RTLib = "compiler-rt"
@@ -294,13 +305,8 @@ func defaultTarget(goos, goarch, triple string) (*TargetSpec, error) {
 			"--image-base", "0x400000",
 			"--gc-sections",
 			"--no-insert-timestamp",
+			"--no-dynamicbase",
 		)
-		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
 	}
@@ -311,22 +317,31 @@ func defaultTarget(goos, goarch, triple string) (*TargetSpec, error) {
 			// systems so we need separate assembly files.
 			suffix = "_windows"
 		}
-		spec.ExtraFiles = append(spec.ExtraFiles, "src/runtime/gc_"+goarch+suffix+".S")
+		spec.ExtraFiles = append(spec.ExtraFiles, "src/runtime/asm_"+goarch+suffix+".S")
 		spec.ExtraFiles = append(spec.ExtraFiles, "src/internal/task/task_stack_"+goarch+suffix+".S")
 	}
 	if goarch != runtime.GOARCH {
 		// Some educated guesses as to how to invoke helper programs.
 		spec.GDB = []string{"gdb-multiarch"}
-		if goarch == "arm" && goos == "linux" {
-			spec.Emulator = []string{"qemu-arm"}
-		}
-		if goarch == "arm64" && goos == "linux" {
-			spec.Emulator = []string{"qemu-aarch64"}
+		if goos == "linux" {
+			switch goarch {
+			case "386":
+				// amd64 can _usually_ run 32-bit programs, so skip the emulator in that case.
+				if runtime.GOARCH != "amd64" {
+					spec.Emulator = "qemu-i386 {}"
+				}
+			case "amd64":
+				spec.Emulator = "qemu-x86_64 {}"
+			case "arm":
+				spec.Emulator = "qemu-arm {}"
+			case "arm64":
+				spec.Emulator = "qemu-aarch64 {}"
+			}
 		}
 	}
 	if goos != runtime.GOOS {
 		if goos == "windows" {
-			spec.Emulator = []string{"wine"}
+			spec.Emulator = "wine {}"
 		}
 	}
 	return &spec, nil
@@ -1,7 +1,8 @@
 package compileopts

 import (
-	"os"
+	"errors"
+	"io/fs"
 	"reflect"
 	"testing"
 )
@@ -17,7 +18,7 @@ func TestLoadTarget(t *testing.T) {
 		t.Error("LoadTarget should have failed with non existing target")
 	}

-	if !os.IsNotExist(err) {
+	if !errors.Is(err, fs.ErrNotExist) {
 		t.Error("LoadTarget failed for wrong reason:", err)
 	}
 }
@@ -29,7 +30,6 @@ func TestOverrideProperties(t *testing.T) {
 		CPU:              "baseCpu",
 		CFlags:           []string{"-base-foo", "-base-bar"},
 		BuildTags:        []string{"bt1", "bt2"},
-		Emulator:         []string{"be1", "be2"},
 		DefaultStackSize: 42,
 		AutoStackSize:    &baseAutoStackSize,
 	}
@@ -38,7 +38,6 @@ func TestOverrideProperties(t *testing.T) {
 		GOOS:             "",
 		CPU:              "chlidCpu",
 		CFlags:           []string{"-child-foo", "-child-bar"},
-		Emulator:         []string{"ce1", "ce2"},
 		AutoStackSize:    &childAutoStackSize,
 		DefaultStackSize: 64,
 	}
@@ -57,9 +56,6 @@ func TestOverrideProperties(t *testing.T) {
 	if !reflect.DeepEqual(base.BuildTags, []string{"bt1", "bt2"}) {
 		t.Errorf("Overriding failed : got %v", base.BuildTags)
 	}
-	if !reflect.DeepEqual(base.Emulator, []string{"ce1", "ce2"}) {
-		t.Errorf("Overriding failed : got %v", base.Emulator)
-	}
 	if *base.AutoStackSize != false {
 		t.Errorf("Overriding failed : got %v", base.AutoStackSize)
 	}
@@ -16,6 +16,8 @@ import "tinygo.org/x/go-llvm"

 var stdlibAliases = map[string]string{
 	// crypto packages
+	"crypto/ed25519/internal/edwards25519/field.feMul":    "crypto/ed25519/internal/edwards25519/field.feMulGeneric",
+	"crypto/ed25519/internal/edwards25519/field.feSquare": "crypto/ed25519/internal/edwards25519/field.feSquareGeneric",
 	"crypto/md5.block":         "crypto/md5.blockGeneric",
 	"crypto/sha1.block":        "crypto/sha1.blockGeneric",
 	"crypto/sha1.blockAMD64":   "crypto/sha1.blockGeneric",
@@ -23,53 +25,10 @@ var stdlibAliases = map[string]string{
 	"crypto/sha512.blockAMD64": "crypto/sha512.blockGeneric",

 	// math package
-	"math.Asin":      "math.asin",
-	"math.Asinh":     "math.asinh",
-	"math.Acos":      "math.acos",
-	"math.Acosh":     "math.acosh",
-	"math.Atan":      "math.atan",
-	"math.Atanh":     "math.atanh",
-	"math.Atan2":     "math.atan2",
-	"math.Cbrt":      "math.cbrt",
-	"math.Ceil":      "math.ceil",
-	"math.archCeil":  "math.ceil",
-	"math.Cos":       "math.cos",
-	"math.Cosh":      "math.cosh",
-	"math.Erf":       "math.erf",
-	"math.Erfc":      "math.erfc",
-	"math.Exp":       "math.exp",
-	"math.archExp":   "math.exp",
-	"math.Expm1":     "math.expm1",
-	"math.Exp2":      "math.exp2",
-	"math.archExp2":  "math.exp2",
-	"math.Floor":     "math.floor",
-	"math.archFloor": "math.floor",
-	"math.Frexp":     "math.frexp",
-	"math.Hypot":     "math.hypot",
 	"math.archHypot": "math.hypot",
-	"math.Ldexp":     "math.ldexp",
-	"math.Log":       "math.log",
-	"math.archLog":   "math.log",
-	"math.Log1p":     "math.log1p",
-	"math.Log10":     "math.log10",
-	"math.Log2":      "math.log2",
-	"math.Max":       "math.max",
 	"math.archMax":   "math.max",
-	"math.Min":       "math.min",
 	"math.archMin":   "math.min",
-	"math.Mod":       "math.mod",
-	"math.Modf":      "math.modf",
 	"math.archModf":  "math.modf",
-	"math.Pow":       "math.pow",
-	"math.Remainder": "math.remainder",
-	"math.Sin":       "math.sin",
-	"math.Sinh":      "math.sinh",
-	"math.Sqrt":      "math.sqrt",
-	"math.archSqrt":  "math.sqrt",
-	"math.Tan":       "math.tan",
-	"math.Tanh":      "math.tanh",
-	"math.Trunc":     "math.trunc",
-	"math.archTrunc": "math.trunc",
 }

 // createAlias implements the function (in the builder) as a call to the alias
@@ -86,7 +45,7 @@ func (b *builder) createAlias(alias llvm.Value) {
 		pos := b.program.Fset.Position(b.fn.Pos())
 		b.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), b.difunc, llvm.Metadata{})
 	}
-	entryBlock := llvm.AddBasicBlock(b.llvmFn, "entry")
+	entryBlock := b.ctx.AddBasicBlock(b.llvmFn, "entry")
 	b.SetInsertPointAtEnd(entryBlock)
 	if b.llvmFn.Type() != alias.Type() {
 		b.addError(b.fn.Pos(), "alias function should have the same type as aliasee "+alias.Name())
@@ -240,8 +240,10 @@ func (b *builder) createRuntimeAssert(assert llvm.Value, blockPrefix, assertFunc
 		}
 	}

+	// Put the fault block at the end of the function and the next block at the
+	// current insert position.
 	faultBlock := b.ctx.AddBasicBlock(b.llvmFn, blockPrefix+".throw")
-	nextBlock := b.ctx.AddBasicBlock(b.llvmFn, blockPrefix+".next")
+	nextBlock := b.insertBasicBlock(blockPrefix + ".next")
 	b.blockExits[b.currentBlock] = nextBlock // adjust outgoing block for phi nodes

 	// Now branch to the out-of-bounds or the regular block.
@@ -4,19 +4,17 @@ import (
 	"fmt"
 	"strings"

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

-// createAtomicOp lowers an atomic library call by lowering it as an LLVM atomic
-// operation. It returns the result of the operation and true if the call could
-// be lowered inline, and false otherwise.
-func (b *builder) createAtomicOp(call *ssa.CallCommon) (llvm.Value, bool) {
-	name := call.Value.(*ssa.Function).Name()
+// createAtomicOp lowers a sync/atomic function by lowering it as an LLVM atomic
+// operation. It returns the result of the operation, or a zero llvm.Value if
+// the result is void.
+func (b *builder) createAtomicOp(name string) llvm.Value {
 	switch name {
 	case "AddInt32", "AddInt64", "AddUint32", "AddUint64", "AddUintptr":
-		ptr := b.getValue(call.Args[0])
-		val := b.getValue(call.Args[1])
+		ptr := b.getValue(b.fn.Params[0])
+		val := b.getValue(b.fn.Params[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)
@@ -29,17 +27,18 @@ func (b *builder) createAtomicOp(call *ssa.CallCommon) (llvm.Value, bool) {
 			}
 			oldVal := b.createCall(fn, []llvm.Value{ptr, val}, "")
 			// Return the new value, not the original value returned.
-			return b.CreateAdd(oldVal, val, ""), true
+			return b.CreateAdd(oldVal, val, "")
 		}
 		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
+		return b.CreateAdd(oldVal, val, "")
 	case "SwapInt32", "SwapInt64", "SwapUint32", "SwapUint64", "SwapUintptr", "SwapPointer":
-		ptr := b.getValue(call.Args[0])
-		val := b.getValue(call.Args[1])
+		ptr := b.getValue(b.fn.Params[0])
+		val := b.getValue(b.fn.Params[1])
 		isPointer := val.Type().TypeKind() == llvm.PointerTypeKind
 		if isPointer {
 			// atomicrmw only supports integers, so cast to an integer.
+			// TODO: this is fixed in LLVM 15.
 			val = b.CreatePtrToInt(val, b.uintptrType, "")
 			ptr = b.CreateBitCast(ptr, llvm.PointerType(val.Type(), 0), "")
 		}
@@ -47,47 +46,23 @@ func (b *builder) createAtomicOp(call *ssa.CallCommon) (llvm.Value, bool) {
 		if isPointer {
 			oldVal = b.CreateIntToPtr(oldVal, b.i8ptrType, "")
 		}
-		return oldVal, true
+		return oldVal
 	case "CompareAndSwapInt32", "CompareAndSwapInt64", "CompareAndSwapUint32", "CompareAndSwapUint64", "CompareAndSwapUintptr", "CompareAndSwapPointer":
-		ptr := b.getValue(call.Args[0])
-		old := b.getValue(call.Args[1])
-		newVal := b.getValue(call.Args[2])
-		if strings.HasSuffix(name, "64") {
-			if strings.HasPrefix(b.Triple, "thumb") {
-				// Work around a bug in LLVM, at least LLVM 11:
-				// https://reviews.llvm.org/D95891
-				// Check for thumbv6m, thumbv7, thumbv7em, and perhaps others.
-				// See also: https://gcc.gnu.org/onlinedocs/gcc/_005f_005fsync-Builtins.html
-				compareAndSwap := b.mod.NamedFunction("__sync_val_compare_and_swap_8")
-				if compareAndSwap.IsNil() {
-					// Declare the function if it isn't already declared.
-					i64Type := b.ctx.Int64Type()
-					fnType := llvm.FunctionType(i64Type, []llvm.Type{llvm.PointerType(i64Type, 0), i64Type, i64Type}, false)
-					compareAndSwap = llvm.AddFunction(b.mod, "__sync_val_compare_and_swap_8", fnType)
-				}
-				actualOldValue := b.CreateCall(compareAndSwap, []llvm.Value{ptr, old, newVal}, "")
-				// The __sync_val_compare_and_swap_8 function returns the old
-				// value. However, we shouldn't return the old value, we should
-				// return whether the compare/exchange was successful. This is
-				// easily done by comparing the returned (actual) old value with
-				// the expected old value passed to
-				// __sync_val_compare_and_swap_8.
-				swapped := b.CreateICmp(llvm.IntEQ, old, actualOldValue, "")
-				return swapped, true
-			}
-		}
+		ptr := b.getValue(b.fn.Params[0])
+		old := b.getValue(b.fn.Params[1])
+		newVal := b.getValue(b.fn.Params[2])
 		tuple := b.CreateAtomicCmpXchg(ptr, old, newVal, llvm.AtomicOrderingSequentiallyConsistent, llvm.AtomicOrderingSequentiallyConsistent, true)
 		swapped := b.CreateExtractValue(tuple, 1, "")
-		return swapped, true
+		return swapped
 	case "LoadInt32", "LoadInt64", "LoadUint32", "LoadUint64", "LoadUintptr", "LoadPointer":
-		ptr := b.getValue(call.Args[0])
+		ptr := b.getValue(b.fn.Params[0])
 		val := b.CreateLoad(ptr, "")
 		val.SetOrdering(llvm.AtomicOrderingSequentiallyConsistent)
 		val.SetAlignment(b.targetData.PrefTypeAlignment(val.Type())) // required
-		return val, true
+		return val
 	case "StoreInt32", "StoreInt64", "StoreUint32", "StoreUint64", "StoreUintptr", "StorePointer":
-		ptr := b.getValue(call.Args[0])
-		val := b.getValue(call.Args[1])
+		ptr := b.getValue(b.fn.Params[0])
+		val := b.getValue(b.fn.Params[1])
 		if strings.HasPrefix(b.Triple, "avr") {
 			// SelectionDAGBuilder is currently missing the "are unaligned atomics allowed" check for stores.
 			vType := val.Type()
@@ -103,13 +78,15 @@ func (b *builder) createAtomicOp(call *ssa.CallCommon) (llvm.Value, bool) {
 			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
+			b.createCall(fn, []llvm.Value{ptr, val, llvm.ConstInt(b.uintptrType, 5, false)}, "")
+			return llvm.Value{}
 		}
 		store := b.CreateStore(val, ptr)
 		store.SetOrdering(llvm.AtomicOrderingSequentiallyConsistent)
 		store.SetAlignment(b.targetData.PrefTypeAlignment(val.Type())) // required
-		return store, true
+		return llvm.Value{}
 	default:
-		return llvm.Value{}, false
+		b.addError(b.fn.Pos(), "unknown atomic operation: "+b.fn.Name())
+		return llvm.Value{}
 	}
 }
@@ -33,17 +33,36 @@ const (
 	paramIsDeferenceableOrNull = 1 << iota
 )

-// createCall creates a new call to runtime.<fnName> with the given arguments.
-func (b *builder) createRuntimeCall(fnName string, args []llvm.Value, name string) llvm.Value {
+// createRuntimeCallCommon creates a runtime call. Use createRuntimeCall or
+// createRuntimeInvoke instead.
+func (b *builder) createRuntimeCallCommon(fnName string, args []llvm.Value, name string, isInvoke bool) llvm.Value {
 	fn := b.program.ImportedPackage("runtime").Members[fnName].(*ssa.Function)
 	llvmFn := b.getFunction(fn)
 	if llvmFn.IsNil() {
 		panic("trying to call non-existent function: " + fn.RelString(nil))
 	}
 	args = append(args, llvm.Undef(b.i8ptrType)) // unused context parameter
+	if isInvoke {
+		return b.createInvoke(llvmFn, args, name)
+	}
 	return b.createCall(llvmFn, args, name)
 }

+// createRuntimeCall creates a new call to runtime.<fnName> with the given
+// arguments.
+func (b *builder) createRuntimeCall(fnName string, args []llvm.Value, name string) llvm.Value {
+	return b.createRuntimeCallCommon(fnName, args, name, false)
+}
+
+// createRuntimeInvoke creates a new call to runtime.<fnName> with the given
+// arguments. If the runtime call panics, control flow is diverted to the
+// landing pad block.
+// Note that "invoke" here is meant in the LLVM sense (a call that can
+// panic/throw), not in the Go sense (an interface method call).
+func (b *builder) createRuntimeInvoke(fnName string, args []llvm.Value, name string) llvm.Value {
+	return b.createRuntimeCallCommon(fnName, args, name, true)
+}
+
 // createCall creates a call to the given function with the arguments possibly
 // expanded.
 func (b *builder) createCall(fn llvm.Value, args []llvm.Value, name string) llvm.Value {
@@ -55,6 +74,15 @@ func (b *builder) createCall(fn llvm.Value, args []llvm.Value, name string) llvm
 	return b.CreateCall(fn, expanded, name)
 }

+// createInvoke is like createCall but continues execution at the landing pad if
+// the call resulted in a panic.
+func (b *builder) createInvoke(fn llvm.Value, args []llvm.Value, name string) llvm.Value {
+	if b.hasDeferFrame() {
+		b.createInvokeCheckpoint()
+	}
+	return b.createCall(fn, args, name)
+}
+
 // Expand an argument type to a list that can be used in a function call
 // parameter list.
 func (c *compilerContext) expandFormalParamType(t llvm.Type, name string, goType types.Type) []paramInfo {
@@ -9,6 +9,7 @@ import (
 	"go/token"
 	"go/types"
 	"math/bits"
+	"path"
 	"path/filepath"
 	"sort"
 	"strconv"
@@ -17,6 +18,7 @@ import (
 	"github.com/tinygo-org/tinygo/compiler/llvmutil"
 	"github.com/tinygo-org/tinygo/loader"
 	"golang.org/x/tools/go/ssa"
+	"golang.org/x/tools/go/types/typeutil"
 	"tinygo.org/x/go-llvm"
 )

@@ -65,7 +67,7 @@ type compilerContext struct {
 	cu               llvm.Metadata
 	difiles          map[string]llvm.Metadata
 	ditypes          map[types.Type]llvm.Metadata
-	llvmTypes        map[types.Type]llvm.Type
+	llvmTypes        typeutil.Map
 	machine          llvm.TargetMachine
 	targetData       llvm.TargetData
 	intType          llvm.Type
@@ -76,6 +78,7 @@ type compilerContext struct {
 	program          *ssa.Program
 	diagnostics      []error
 	astComments      map[string]*ast.CommentGroup
+	embedGlobals     map[string][]*loader.EmbedFile
 	pkg              *types.Package
 	packageDir       string // directory for this package
 	runtimePkg       *types.Package
@@ -89,7 +92,6 @@ func newCompilerContext(moduleName string, machine llvm.TargetMachine, config *C
 		DumpSSA:     dumpSSA,
 		difiles:     make(map[string]llvm.Metadata),
 		ditypes:     make(map[types.Type]llvm.Metadata),
-		llvmTypes:   make(map[types.Type]llvm.Type),
 		machine:     machine,
 		targetData:  machine.CreateTargetData(),
 		astComments: map[string]*ast.CommentGroup{},
@@ -137,6 +139,8 @@ type builder struct {
 	currentBlock      *ssa.BasicBlock
 	phis              []phiNode
 	deferPtr          llvm.Value
+	deferFrame        llvm.Value
+	landingpad        llvm.BasicBlock
 	difunc            llvm.Metadata
 	dilocals          map[*types.Var]llvm.Metadata
 	initInlinedAt     llvm.Metadata            // fake inlinedAt position
@@ -234,10 +238,15 @@ func Sizes(machine llvm.TargetMachine) types.Sizes {
 		panic("unknown pointer size")
 	}

+	// Construct a complex128 type because that's likely the type with the
+	// biggest alignment on most/all ABIs.
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	complex128Type := ctx.StructType([]llvm.Type{ctx.DoubleType(), ctx.DoubleType()}, false)
 	return &stdSizes{
 		IntSize:  int64(intWidth / 8),
 		PtrSize:  int64(targetData.PointerSize()),
-		MaxAlign: int64(targetData.PrefTypeAlignment(targetData.IntPtrType())),
+		MaxAlign: int64(targetData.ABITypeAlignment(complex128Type)),
 	}
 }

@@ -245,6 +254,7 @@ func Sizes(machine llvm.TargetMachine) types.Sizes {
 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.embedGlobals = pkg.EmbedGlobals
 	c.pkg = pkg.Pkg
 	c.runtimePkg = ssaPkg.Prog.ImportedPackage("runtime").Pkg
 	c.program = ssaPkg.Prog
@@ -296,6 +306,7 @@ func CompilePackage(moduleName string, pkg *loader.Package, ssaPkg *ssa.Package,
 			}),
 		)
 		c.dibuilder.Finalize()
+		c.dibuilder.Destroy()
 	}

 	return c.mod, c.diagnostics
@@ -314,12 +325,16 @@ func (c *compilerContext) getLLVMRuntimeType(name string) llvm.Type {
 // important for named struct types (which should only be created once).
 func (c *compilerContext) getLLVMType(goType types.Type) llvm.Type {
 	// Try to load the LLVM type from the cache.
-	if t, ok := c.llvmTypes[goType]; ok {
-		return t
+	// Note: *types.Named isn't unique when working with generics.
+	// See https://github.com/golang/go/issues/53914
+	// This is the reason for using typeutil.Map to lookup LLVM types for Go types.
+	ival := c.llvmTypes.At(goType)
+	if ival != nil {
+		return ival.(llvm.Type)
 	}
 	// Not already created, so adding this type to the cache.
 	llvmType := c.makeLLVMType(goType)
-	c.llvmTypes[goType] = llvmType
+	c.llvmTypes.Set(goType, llvmType)
 	return llvmType
 }

@@ -373,9 +388,9 @@ func (c *compilerContext) makeLLVMType(goType types.Type) llvm.Type {
 			// in LLVM IR, named structs are implemented as named structs in
 			// LLVM. This is because it is otherwise impossible to create
 			// self-referencing types such as linked lists.
-			llvmName := typ.Obj().Pkg().Path() + "." + typ.Obj().Name()
+			llvmName := typ.String()
 			llvmType := c.ctx.StructCreateNamed(llvmName)
-			c.llvmTypes[goType] = llvmType // avoid infinite recursion
+			c.llvmTypes.Set(goType, llvmType) // avoid infinite recursion
 			underlying := c.getLLVMType(st)
 			llvmType.StructSetBody(underlying.StructElementTypes(), false)
 			return llvmType
@@ -400,6 +415,8 @@ func (c *compilerContext) makeLLVMType(goType types.Type) llvm.Type {
 			members[i] = c.getLLVMType(typ.Field(i).Type())
 		}
 		return c.ctx.StructType(members, false)
+	case *types.TypeParam:
+		return c.getLLVMType(typ.Underlying())
 	case *types.Tuple:
 		members := make([]llvm.Type, typ.Len())
 		for i := 0; i < typ.Len(); i++ {
@@ -598,6 +615,8 @@ func (c *compilerContext) createDIType(typ types.Type) llvm.Metadata {
 		})
 		temporaryMDNode.ReplaceAllUsesWith(md)
 		return md
+	case *types.TypeParam:
+		return c.getDIType(typ.Underlying())
 	default:
 		panic("unknown type while generating DWARF debug type: " + typ.String())
 	}
@@ -667,7 +686,7 @@ func (b *builder) getLocalVariable(variable *types.Var) llvm.Metadata {
 				Name:           param.Name(),
 				File:           b.getDIFile(pos.Filename),
 				Line:           pos.Line,
-				Type:           b.getDIType(variable.Type()),
+				Type:           b.getDIType(param.Type()),
 				AlwaysPreserve: true,
 				ArgNo:          i + 1,
 			})
@@ -765,10 +784,25 @@ func (c *compilerContext) createPackage(irbuilder llvm.Builder, pkg *ssa.Package
 		member := pkg.Members[name]
 		switch member := member.(type) {
 		case *ssa.Function:
+			if member.Synthetic == "generic function" {
+				// Do not try to build generic (non-instantiated) functions.
+				continue
+			}
 			// Create the function definition.
 			b := newBuilder(c, irbuilder, member)
+			if _, ok := mathToLLVMMapping[member.RelString(nil)]; ok {
+				// The body of this function (if there is one) is ignored and
+				// replaced with a LLVM intrinsic call.
+				b.defineMathOp()
+				continue
+			}
 			if member.Blocks == nil {
-				continue // external function
+				// Try to define this as an intrinsic function.
+				b.defineIntrinsicFunction()
+				// It might not be an intrinsic function but simply an external
+				// function (defined via //go:linkname). Leave it undefined in
+				// that case.
+				continue
 			}
 			b.createFunction()
 		case *ssa.Type:
@@ -785,6 +819,9 @@ func (c *compilerContext) createPackage(irbuilder llvm.Builder, pkg *ssa.Package
 			for _, method := range methods {
 				// Parse this method.
 				fn := pkg.Prog.MethodValue(method)
+				if fn == nil {
+					continue // probably a generic method
+				}
 				if fn.Blocks == nil {
 					continue // external function
 				}
@@ -809,7 +846,9 @@ func (c *compilerContext) createPackage(irbuilder llvm.Builder, pkg *ssa.Package
 			// Global variable.
 			info := c.getGlobalInfo(member)
 			global := c.getGlobal(member)
-			if !info.extern {
+			if files, ok := c.embedGlobals[member.Name()]; ok {
+				c.createEmbedGlobal(member, global, files)
+			} else if !info.extern {
 				global.SetInitializer(llvm.ConstNull(global.Type().ElementType()))
 				global.SetVisibility(llvm.HiddenVisibility)
 				if info.section != "" {
@@ -843,10 +882,155 @@ func (c *compilerContext) createPackage(irbuilder llvm.Builder, pkg *ssa.Package
 	}
 }

-// createFunction builds the LLVM IR implementation for this function. The
-// function must not yet be defined, otherwise this function will create a
-// diagnostic.
-func (b *builder) createFunction() {
+// createEmbedGlobal creates an initializer for a //go:embed global variable.
+func (c *compilerContext) createEmbedGlobal(member *ssa.Global, global llvm.Value, files []*loader.EmbedFile) {
+	switch typ := member.Type().(*types.Pointer).Elem().Underlying().(type) {
+	case *types.Basic:
+		// String type.
+		if typ.Kind() != types.String {
+			// This is checked at the AST level, so should be unreachable.
+			panic("expected a string type")
+		}
+		if len(files) != 1 {
+			c.addError(member.Pos(), fmt.Sprintf("//go:embed for a string should be given exactly one file, got %d", len(files)))
+			return
+		}
+		strObj := c.getEmbedFileString(files[0])
+		global.SetInitializer(strObj)
+		global.SetVisibility(llvm.HiddenVisibility)
+
+	case *types.Slice:
+		if typ.Elem().Underlying().(*types.Basic).Kind() != types.Byte {
+			// This is checked at the AST level, so should be unreachable.
+			panic("expected a byte slice")
+		}
+		if len(files) != 1 {
+			c.addError(member.Pos(), fmt.Sprintf("//go:embed for a string should be given exactly one file, got %d", len(files)))
+			return
+		}
+		file := files[0]
+		bufferValue := c.ctx.ConstString(string(file.Data), false)
+		bufferGlobal := llvm.AddGlobal(c.mod, bufferValue.Type(), c.pkg.Path()+"$embedslice")
+		bufferGlobal.SetInitializer(bufferValue)
+		bufferGlobal.SetLinkage(llvm.InternalLinkage)
+		bufferGlobal.SetAlignment(1)
+		slicePtr := llvm.ConstInBoundsGEP(bufferGlobal, []llvm.Value{
+			llvm.ConstInt(c.uintptrType, 0, false),
+			llvm.ConstInt(c.uintptrType, 0, false),
+		})
+		sliceLen := llvm.ConstInt(c.uintptrType, file.Size, false)
+		sliceObj := c.ctx.ConstStruct([]llvm.Value{slicePtr, sliceLen, sliceLen}, false)
+		global.SetInitializer(sliceObj)
+		global.SetVisibility(llvm.HiddenVisibility)
+
+	case *types.Struct:
+		// Assume this is an embed.FS struct:
+		// https://cs.opensource.google/go/go/+/refs/tags/go1.18.2:src/embed/embed.go;l=148
+		// It looks like this:
+		//   type FS struct {
+		//       files *file
+		//   }
+
+		// Make a slice of the files, as they will appear in the binary. They
+		// are sorted in a special way to allow for binary searches, see
+		// src/embed/embed.go for details.
+		dirset := map[string]struct{}{}
+		var allFiles []*loader.EmbedFile
+		for _, file := range files {
+			allFiles = append(allFiles, file)
+			dirname := file.Name
+			for {
+				dirname, _ = path.Split(path.Clean(dirname))
+				if dirname == "" {
+					break
+				}
+				if _, ok := dirset[dirname]; ok {
+					break
+				}
+				dirset[dirname] = struct{}{}
+				allFiles = append(allFiles, &loader.EmbedFile{
+					Name: dirname,
+				})
+			}
+		}
+		sort.Slice(allFiles, func(i, j int) bool {
+			dir1, name1 := path.Split(path.Clean(allFiles[i].Name))
+			dir2, name2 := path.Split(path.Clean(allFiles[j].Name))
+			if dir1 != dir2 {
+				return dir1 < dir2
+			}
+			return name1 < name2
+		})
+
+		// Make the backing array for the []files slice. This is a LLVM global.
+		embedFileStructType := c.getLLVMType(typ.Field(0).Type().(*types.Pointer).Elem().(*types.Slice).Elem())
+		var fileStructs []llvm.Value
+		for _, file := range allFiles {
+			fileStruct := llvm.ConstNull(embedFileStructType)
+			name := c.createConst(ssa.NewConst(constant.MakeString(file.Name), types.Typ[types.String]))
+			fileStruct = llvm.ConstInsertValue(fileStruct, name, []uint32{0}) // "name" field
+			if file.Hash != "" {
+				data := c.getEmbedFileString(file)
+				fileStruct = llvm.ConstInsertValue(fileStruct, data, []uint32{1}) // "data" field
+			}
+			fileStructs = append(fileStructs, fileStruct)
+		}
+		sliceDataInitializer := llvm.ConstArray(embedFileStructType, fileStructs)
+		sliceDataGlobal := llvm.AddGlobal(c.mod, sliceDataInitializer.Type(), c.pkg.Path()+"$embedfsfiles")
+		sliceDataGlobal.SetInitializer(sliceDataInitializer)
+		sliceDataGlobal.SetLinkage(llvm.InternalLinkage)
+		sliceDataGlobal.SetGlobalConstant(true)
+		sliceDataGlobal.SetUnnamedAddr(true)
+		sliceDataGlobal.SetAlignment(c.targetData.ABITypeAlignment(sliceDataInitializer.Type()))
+
+		// Create the slice object itself.
+		// Because embed.FS refers to it as *[]embed.file instead of a plain
+		// []embed.file, we have to store this as a global.
+		slicePtr := llvm.ConstInBoundsGEP(sliceDataGlobal, []llvm.Value{
+			llvm.ConstInt(c.uintptrType, 0, false),
+			llvm.ConstInt(c.uintptrType, 0, false),
+		})
+		sliceLen := llvm.ConstInt(c.uintptrType, uint64(len(fileStructs)), false)
+		sliceInitializer := c.ctx.ConstStruct([]llvm.Value{slicePtr, sliceLen, sliceLen}, false)
+		sliceGlobal := llvm.AddGlobal(c.mod, sliceInitializer.Type(), c.pkg.Path()+"$embedfsslice")
+		sliceGlobal.SetInitializer(sliceInitializer)
+		sliceGlobal.SetLinkage(llvm.InternalLinkage)
+		sliceGlobal.SetGlobalConstant(true)
+		sliceGlobal.SetUnnamedAddr(true)
+		sliceGlobal.SetAlignment(c.targetData.ABITypeAlignment(sliceInitializer.Type()))
+
+		// Define the embed.FS struct. It has only one field: the files (as a
+		// *[]embed.file).
+		globalInitializer := llvm.ConstNull(c.getLLVMType(member.Type().(*types.Pointer).Elem()))
+		globalInitializer = llvm.ConstInsertValue(globalInitializer, sliceGlobal, []uint32{0})
+		global.SetInitializer(globalInitializer)
+		global.SetVisibility(llvm.HiddenVisibility)
+		global.SetAlignment(c.targetData.ABITypeAlignment(globalInitializer.Type()))
+	}
+}
+
+// getEmbedFileString returns the (constant) string object with the contents of
+// the given file. This is a llvm.Value of a regular Go string.
+func (c *compilerContext) getEmbedFileString(file *loader.EmbedFile) llvm.Value {
+	dataGlobalName := "embed/file_" + file.Hash
+	dataGlobal := c.mod.NamedGlobal(dataGlobalName)
+	if dataGlobal.IsNil() {
+		dataGlobalType := llvm.ArrayType(c.ctx.Int8Type(), int(file.Size))
+		dataGlobal = llvm.AddGlobal(c.mod, dataGlobalType, dataGlobalName)
+	}
+	strPtr := llvm.ConstInBoundsGEP(dataGlobal, []llvm.Value{
+		llvm.ConstInt(c.uintptrType, 0, false),
+		llvm.ConstInt(c.uintptrType, 0, false),
+	})
+	strLen := llvm.ConstInt(c.uintptrType, file.Size, false)
+	return llvm.ConstNamedStruct(c.getLLVMRuntimeType("_string"), []llvm.Value{strPtr, strLen})
+}
+
+// Start defining a function so that it can be filled with instructions: load
+// parameters, create basic blocks, and set up debug information.
+// This is separated out from createFunction() so that it is also usable to
+// define compiler intrinsics like the atomic operations in sync/atomic.
+func (b *builder) createFunctionStart(intrinsic bool) {
 	if b.DumpSSA {
 		fmt.Printf("\nfunc %s:\n", b.fn)
 	}
@@ -859,9 +1043,17 @@ func (b *builder) createFunction() {
 		b.addError(b.fn.Pos(), errValue)
 		return
 	}
+
 	b.addStandardDefinedAttributes(b.llvmFn)
 	if !b.info.exported {
-		b.llvmFn.SetVisibility(llvm.HiddenVisibility)
+		// Do not set visibility for local linkage (internal or private).
+		// Otherwise a "local linkage requires default visibility"
+		// assertion error in llvm-project/llvm/include/llvm/IR/GlobalValue.h:236
+		// is thrown.
+		if b.llvmFn.Linkage() != llvm.InternalLinkage &&
+			b.llvmFn.Linkage() != llvm.PrivateLinkage {
+			b.llvmFn.SetVisibility(llvm.HiddenVisibility)
+		}
 		b.llvmFn.SetUnnamedAddr(true)
 	}
 	if b.info.section != "" {
@@ -911,12 +1103,21 @@ func (b *builder) createFunction() {
 	}

 	// Pre-create all basic blocks in the function.
-	for _, block := range b.fn.DomPreorder() {
-		llvmBlock := b.ctx.AddBasicBlock(b.llvmFn, block.Comment)
-		b.blockEntries[block] = llvmBlock
-		b.blockExits[block] = llvmBlock
+	var entryBlock llvm.BasicBlock
+	if intrinsic {
+		// This function isn't defined in Go SSA. It is probably a compiler
+		// intrinsic (like an atomic operation). Create the entry block
+		// manually.
+		entryBlock = b.ctx.AddBasicBlock(b.llvmFn, "entry")
+	} else {
+		for _, block := range b.fn.DomPreorder() {
+			llvmBlock := b.ctx.AddBasicBlock(b.llvmFn, block.Comment)
+			b.blockEntries[block] = llvmBlock
+			b.blockExits[block] = llvmBlock
+		}
+		// Normal functions have an entry block.
+		entryBlock = b.blockEntries[b.fn.Blocks[0]]
 	}
-	entryBlock := b.blockEntries[b.fn.Blocks[0]]
 	b.SetInsertPointAtEnd(entryBlock)

 	if b.fn.Synthetic == "package initializer" {
@@ -952,10 +1153,10 @@ func (b *builder) createFunction() {
 			} else {
 				fieldOffsets := b.expandFormalParamOffsets(llvmType)
 				for i, field := range fields {
-					expr := b.dibuilder.CreateExpression([]int64{
-						0x1000,                     // DW_OP_LLVM_fragment
-						int64(fieldOffsets[i]) * 8, // offset in bits
-						int64(b.targetData.TypeAllocSize(field.Type())) * 8, // size in bits
+					expr := b.dibuilder.CreateExpression([]uint64{
+						0x1000,              // DW_OP_LLVM_fragment
+						fieldOffsets[i] * 8, // offset in bits
+						b.targetData.TypeAllocSize(field.Type()) * 8, // size in bits
 					})
 					b.dibuilder.InsertValueAtEnd(field, dbgParam, expr, loc, entryBlock)
 				}
@@ -991,6 +1192,13 @@ func (b *builder) createFunction() {
 		// them.
 		b.deferInitFunc()
 	}
+}
+
+// createFunction builds the LLVM IR implementation for this function. The
+// function must not yet be defined, otherwise this function will create a
+// diagnostic.
+func (b *builder) createFunction() {
+	b.createFunctionStart(false)

 	// Fill blocks with instructions.
 	for _, block := range b.fn.DomPreorder() {
@@ -1038,6 +1246,12 @@ func (b *builder) createFunction() {
 		}
 	}

+	if b.hasDeferFrame() {
+		// Create the landing pad block, where execution continues after a
+		// panic.
+		b.createLandingPad()
+	}
+
 	// Resolve phi nodes
 	for _, phi := range b.phis {
 		block := phi.ssa.Block()
@@ -1063,6 +1277,7 @@ func (b *builder) createFunction() {
 	// Create anonymous functions (closures etc.).
 	for _, sub := range b.fn.AnonFuncs {
 		b := newBuilder(b.compilerContext, b.Builder, sub)
+		b.llvmFn.SetLinkage(llvm.InternalLinkage)
 		b.createFunction()
 	}
 }
@@ -1165,9 +1380,12 @@ func (b *builder) createInstruction(instr ssa.Instruction) {
 		b.createMapUpdate(mapType.Key(), m, key, value, instr.Pos())
 	case *ssa.Panic:
 		value := b.getValue(instr.X)
-		b.createRuntimeCall("_panic", []llvm.Value{value}, "")
+		b.createRuntimeInvoke("_panic", []llvm.Value{value}, "")
 		b.CreateUnreachable()
 	case *ssa.Return:
+		if b.hasDeferFrame() {
+			b.createRuntimeCall("destroyDeferFrame", []llvm.Value{b.deferFrame}, "")
+		}
 		if len(instr.Results) == 0 {
 			b.CreateRetVoid()
 		} else if len(instr.Results) == 1 {
@@ -1228,7 +1446,7 @@ func (b *builder) createBuiltin(argTypes []types.Type, argValues []llvm.Value, c
 	case "cap":
 		value := argValues[0]
 		var llvmCap llvm.Value
-		switch argTypes[0].(type) {
+		switch argTypes[0].Underlying().(type) {
 		case *types.Chan:
 			llvmCap = b.createRuntimeCall("chanCap", []llvm.Value{value}, "cap")
 		case *types.Slice:
@@ -1344,6 +1562,12 @@ func (b *builder) createBuiltin(argTypes []types.Type, argValues []llvm.Value, c
 			case *types.Pointer:
 				ptrValue := b.CreatePtrToInt(value, b.uintptrType, "")
 				b.createRuntimeCall("printptr", []llvm.Value{ptrValue}, "")
+			case *types.Slice:
+				bufptr := b.CreateExtractValue(value, 0, "")
+				buflen := b.CreateExtractValue(value, 1, "")
+				bufcap := b.CreateExtractValue(value, 2, "")
+				ptrValue := b.CreatePtrToInt(bufptr, b.uintptrType, "")
+				b.createRuntimeCall("printslice", []llvm.Value{ptrValue, buflen, bufcap}, "")
 			default:
 				return llvm.Value{}, b.makeError(pos, "unknown arg type: "+typ.String())
 			}
@@ -1356,7 +1580,13 @@ func (b *builder) createBuiltin(argTypes []types.Type, argValues []llvm.Value, c
 		cplx := argValues[0]
 		return b.CreateExtractValue(cplx, 0, "real"), nil
 	case "recover":
-		return b.createRuntimeCall("_recover", nil, ""), nil
+		useParentFrame := uint64(0)
+		if b.hasDeferFrame() {
+			// recover() should return the panic value of the parent function,
+			// not of the current function.
+			useParentFrame = 1
+		}
+		return b.createRuntimeCall("_recover", []llvm.Value{llvm.ConstInt(b.ctx.Int1Type(), useParentFrame, false)}, ""), nil
 	case "ssa:wrapnilchk":
 		// TODO: do an actual nil check?
 		return argValues[0], nil
@@ -1368,6 +1598,20 @@ func (b *builder) createBuiltin(argTypes []types.Type, argValues []llvm.Value, c
 		ptr := argValues[0]
 		len := argValues[1]
 		return b.CreateGEP(ptr, []llvm.Value{len}, ""), nil
+	case "Alignof": // unsafe.Alignof
+		align := b.targetData.ABITypeAlignment(argValues[0].Type())
+		return llvm.ConstInt(b.uintptrType, uint64(align), false), nil
+	case "Offsetof": // unsafe.Offsetof
+		// This builtin is a bit harder to implement and may need a bit of
+		// refactoring to work (it may be easier to implement if we have access
+		// to the underlying Go SSA instruction). It is also rarely used: it
+		// only applies in generic code and unsafe.Offsetof isn't very commonly
+		// used anyway.
+		// In other words, postpone it to some other day.
+		return llvm.Value{}, b.makeError(pos, "todo: unsafe.Offsetof")
+	case "Sizeof": // unsafe.Sizeof
+		size := b.targetData.TypeAllocSize(argValues[0].Type())
+		return llvm.ConstInt(b.uintptrType, size, false), nil
 	case "Slice": // unsafe.Slice
 		// This creates a slice from a pointer and a length.
 		// Note that the exception mentioned in the documentation (if the
@@ -1416,15 +1660,6 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 		// applied) function call. If it is anonymous, it may be a closure.
 		name := fn.RelString(nil)
 		switch {
-		case name == "runtime.memcpy" || name == "runtime.memmove" || name == "reflect.memcpy":
-			return b.createMemoryCopyCall(fn, instr.Args)
-		case name == "runtime.memzero":
-			return b.createMemoryZeroCall(instr.Args)
-		case name == "math.Ceil" || name == "math.Floor" || name == "math.Sqrt" || name == "math.Trunc":
-			result, ok := b.createMathOp(instr)
-			if ok {
-				return result, nil
-			}
 		case name == "device.Asm" || name == "device/arm.Asm" || name == "device/arm64.Asm" || name == "device/avr.Asm" || name == "device/riscv.Asm":
 			return b.createInlineAsm(instr.Args)
 		case name == "device.AsmFull" || name == "device/arm.AsmFull" || name == "device/arm64.AsmFull" || name == "device/avr.AsmFull" || name == "device/riscv.AsmFull":
@@ -1435,22 +1670,16 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 			return b.emitSV64Call(instr.Args)
 		case strings.HasPrefix(name, "(device/riscv.CSR)."):
 			return b.emitCSROperation(instr)
-		case strings.HasPrefix(name, "syscall.Syscall"):
+		case strings.HasPrefix(name, "syscall.Syscall") || strings.HasPrefix(name, "syscall.RawSyscall"):
 			return b.createSyscall(instr)
 		case strings.HasPrefix(name, "syscall.rawSyscallNoError"):
 			return b.createRawSyscallNoError(instr)
-		case strings.HasPrefix(name, "runtime/volatile.Load"):
-			return b.createVolatileLoad(instr)
-		case strings.HasPrefix(name, "runtime/volatile.Store"):
-			return b.createVolatileStore(instr)
-		case strings.HasPrefix(name, "sync/atomic."):
-			val, ok := b.createAtomicOp(instr)
-			if ok {
-				// This call could be lowered as an atomic operation.
-				return val, nil
+		case name == "runtime.supportsRecover":
+			supportsRecover := uint64(0)
+			if b.supportsRecover() {
+				supportsRecover = 1
 			}
-			// This call couldn't be lowered as an atomic operation, it's
-			// probably something else. Continue as usual.
+			return llvm.ConstInt(b.ctx.Int1Type(), supportsRecover, false), nil
 		case name == "runtime/interrupt.New":
 			return b.createInterruptGlobal(instr)
 		}
@@ -1464,6 +1693,14 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 		case *ssa.Function:
 			// Regular function call. No context is necessary.
 			context = llvm.Undef(b.i8ptrType)
+			if info.variadic && len(fn.Params) == 0 {
+				// This matches Clang, see: https://godbolt.org/z/Gqv49xKMq
+				// Eventually we might be able to eliminate this special case
+				// entirely. For details, see:
+				// https://discourse.llvm.org/t/rfc-enabling-wstrict-prototypes-by-default-in-c/60521
+				fnType := llvm.FunctionType(callee.Type().ElementType().ReturnType(), nil, false)
+				callee = llvm.ConstBitCast(callee, llvm.PointerType(fnType, b.funcPtrAddrSpace))
+			}
 		case *ssa.MakeClosure:
 			// A call on a func value, but the callee is trivial to find. For
 			// example: immediately applied functions.
@@ -1505,7 +1742,7 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 		params = append(params, context)
 	}

-	return b.createCall(callee, params, ""), nil
+	return b.createInvoke(callee, params, ""), nil
 }

 // getValue returns the LLVM value of a constant, function value, global, or
@@ -1549,7 +1786,11 @@ func (c *compilerContext) maxSliceSize(elementType llvm.Type) uint64 {
 	// Determine the maximum allowed size for a slice. The biggest possible
 	// pointer (starting from 0) would be maxPointerValue*sizeof(elementType) so
 	// divide by the element type to get the real maximum size.
-	maxSize := maxPointerValue / c.targetData.TypeAllocSize(elementType)
+	elementSize := c.targetData.TypeAllocSize(elementType)
+	if elementSize == 0 {
+		elementSize = 1
+	}
+	maxSize := maxPointerValue / elementSize

 	// len(slice) is an int. Make sure the length remains small enough to fit in
 	// an int.
@@ -1571,8 +1812,9 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 	switch expr := expr.(type) {
 	case *ssa.Alloc:
 		typ := b.getLLVMType(expr.Type().Underlying().(*types.Pointer).Elem())
-		if expr.Heap {
-			size := b.targetData.TypeAllocSize(typ)
+		size := b.targetData.TypeAllocSize(typ)
+		// Move all "large" allocations to the heap.  This value is also transform.maxStackAlloc.
+		if expr.Heap || size > 256 {
 			// Calculate ^uintptr(0)
 			maxSize := llvm.ConstNot(llvm.ConstInt(b.uintptrType, 0, false)).ZExtValue()
 			if size > maxSize {
@@ -2451,42 +2693,41 @@ func (b *builder) createBinOp(op token.Token, typ, ytyp types.Type, x, y llvm.Va
 }

 // createConst creates a LLVM constant value from a Go constant.
-func (b *builder) createConst(expr *ssa.Const) llvm.Value {
+func (c *compilerContext) createConst(expr *ssa.Const) llvm.Value {
 	switch typ := expr.Type().Underlying().(type) {
 	case *types.Basic:
-		llvmType := b.getLLVMType(typ)
+		llvmType := c.getLLVMType(typ)
 		if typ.Info()&types.IsBoolean != 0 {
-			b := constant.BoolVal(expr.Value)
 			n := uint64(0)
-			if b {
+			if constant.BoolVal(expr.Value) {
 				n = 1
 			}
 			return llvm.ConstInt(llvmType, n, false)
 		} else if typ.Info()&types.IsString != 0 {
 			str := constant.StringVal(expr.Value)
-			strLen := llvm.ConstInt(b.uintptrType, uint64(len(str)), false)
+			strLen := llvm.ConstInt(c.uintptrType, uint64(len(str)), false)
 			var strPtr llvm.Value
 			if str != "" {
-				objname := b.pkg.Path() + "$string"
-				global := llvm.AddGlobal(b.mod, llvm.ArrayType(b.ctx.Int8Type(), len(str)), objname)
-				global.SetInitializer(b.ctx.ConstString(str, false))
+				objname := c.pkg.Path() + "$string"
+				global := llvm.AddGlobal(c.mod, llvm.ArrayType(c.ctx.Int8Type(), len(str)), objname)
+				global.SetInitializer(c.ctx.ConstString(str, false))
 				global.SetLinkage(llvm.InternalLinkage)
 				global.SetGlobalConstant(true)
 				global.SetUnnamedAddr(true)
 				global.SetAlignment(1)
-				zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
-				strPtr = b.CreateInBoundsGEP(global, []llvm.Value{zero, zero}, "")
+				zero := llvm.ConstInt(c.ctx.Int32Type(), 0, false)
+				strPtr = llvm.ConstInBoundsGEP(global, []llvm.Value{zero, zero})
 			} else {
-				strPtr = llvm.ConstNull(b.i8ptrType)
+				strPtr = llvm.ConstNull(c.i8ptrType)
 			}
-			strObj := llvm.ConstNamedStruct(b.getLLVMRuntimeType("_string"), []llvm.Value{strPtr, strLen})
+			strObj := llvm.ConstNamedStruct(c.getLLVMRuntimeType("_string"), []llvm.Value{strPtr, strLen})
 			return strObj
 		} else if typ.Kind() == types.UnsafePointer {
 			if !expr.IsNil() {
 				value, _ := constant.Uint64Val(constant.ToInt(expr.Value))
-				return llvm.ConstIntToPtr(llvm.ConstInt(b.uintptrType, value, false), b.i8ptrType)
+				return llvm.ConstIntToPtr(llvm.ConstInt(c.uintptrType, value, false), c.i8ptrType)
 			}
-			return llvm.ConstNull(b.i8ptrType)
+			return llvm.ConstNull(c.i8ptrType)
 		} else if typ.Info()&types.IsUnsigned != 0 {
 			n, _ := constant.Uint64Val(constant.ToInt(expr.Value))
 			return llvm.ConstInt(llvmType, n, false)
@@ -2497,18 +2738,18 @@ func (b *builder) createConst(expr *ssa.Const) llvm.Value {
 			n, _ := constant.Float64Val(expr.Value)
 			return llvm.ConstFloat(llvmType, n)
 		} else if typ.Kind() == types.Complex64 {
-			r := b.createConst(ssa.NewConst(constant.Real(expr.Value), types.Typ[types.Float32]))
-			i := b.createConst(ssa.NewConst(constant.Imag(expr.Value), types.Typ[types.Float32]))
-			cplx := llvm.Undef(b.ctx.StructType([]llvm.Type{b.ctx.FloatType(), b.ctx.FloatType()}, false))
-			cplx = b.CreateInsertValue(cplx, r, 0, "")
-			cplx = b.CreateInsertValue(cplx, i, 1, "")
+			r := c.createConst(ssa.NewConst(constant.Real(expr.Value), types.Typ[types.Float32]))
+			i := c.createConst(ssa.NewConst(constant.Imag(expr.Value), types.Typ[types.Float32]))
+			cplx := llvm.Undef(c.ctx.StructType([]llvm.Type{c.ctx.FloatType(), c.ctx.FloatType()}, false))
+			cplx = llvm.ConstInsertValue(cplx, r, []uint32{0})
+			cplx = llvm.ConstInsertValue(cplx, i, []uint32{1})
 			return cplx
 		} else if typ.Kind() == types.Complex128 {
-			r := b.createConst(ssa.NewConst(constant.Real(expr.Value), types.Typ[types.Float64]))
-			i := b.createConst(ssa.NewConst(constant.Imag(expr.Value), types.Typ[types.Float64]))
-			cplx := llvm.Undef(b.ctx.StructType([]llvm.Type{b.ctx.DoubleType(), b.ctx.DoubleType()}, false))
-			cplx = b.CreateInsertValue(cplx, r, 0, "")
-			cplx = b.CreateInsertValue(cplx, i, 1, "")
+			r := c.createConst(ssa.NewConst(constant.Real(expr.Value), types.Typ[types.Float64]))
+			i := c.createConst(ssa.NewConst(constant.Imag(expr.Value), types.Typ[types.Float64]))
+			cplx := llvm.Undef(c.ctx.StructType([]llvm.Type{c.ctx.DoubleType(), c.ctx.DoubleType()}, false))
+			cplx = llvm.ConstInsertValue(cplx, r, []uint32{0})
+			cplx = llvm.ConstInsertValue(cplx, i, []uint32{1})
 			return cplx
 		} else {
 			panic("unknown constant of basic type: " + expr.String())
@@ -2517,35 +2758,35 @@ func (b *builder) createConst(expr *ssa.Const) llvm.Value {
 		if expr.Value != nil {
 			panic("expected nil chan constant")
 		}
-		return llvm.ConstNull(b.getLLVMType(expr.Type()))
+		return llvm.ConstNull(c.getLLVMType(expr.Type()))
 	case *types.Signature:
 		if expr.Value != nil {
 			panic("expected nil signature constant")
 		}
-		return llvm.ConstNull(b.getLLVMType(expr.Type()))
+		return llvm.ConstNull(c.getLLVMType(expr.Type()))
 	case *types.Interface:
 		if expr.Value != nil {
 			panic("expected nil interface constant")
 		}
 		// Create a generic nil interface with no dynamic type (typecode=0).
 		fields := []llvm.Value{
-			llvm.ConstInt(b.uintptrType, 0, false),
-			llvm.ConstPointerNull(b.i8ptrType),
+			llvm.ConstInt(c.uintptrType, 0, false),
+			llvm.ConstPointerNull(c.i8ptrType),
 		}
-		return llvm.ConstNamedStruct(b.getLLVMRuntimeType("_interface"), fields)
+		return llvm.ConstNamedStruct(c.getLLVMRuntimeType("_interface"), fields)
 	case *types.Pointer:
 		if expr.Value != nil {
 			panic("expected nil pointer constant")
 		}
-		return llvm.ConstPointerNull(b.getLLVMType(typ))
+		return llvm.ConstPointerNull(c.getLLVMType(typ))
 	case *types.Slice:
 		if expr.Value != nil {
 			panic("expected nil slice constant")
 		}
-		elemType := b.getLLVMType(typ.Elem())
+		elemType := c.getLLVMType(typ.Elem())
 		llvmPtr := llvm.ConstPointerNull(llvm.PointerType(elemType, 0))
-		llvmLen := llvm.ConstInt(b.uintptrType, 0, false)
-		slice := b.ctx.ConstStruct([]llvm.Value{
+		llvmLen := llvm.ConstInt(c.uintptrType, 0, false)
+		slice := c.ctx.ConstStruct([]llvm.Value{
 			llvmPtr, // backing array
 			llvmLen, // len
 			llvmLen, // cap
@@ -2556,7 +2797,7 @@ func (b *builder) createConst(expr *ssa.Const) llvm.Value {
 			// I believe this is not allowed by the Go spec.
 			panic("non-nil map constant")
 		}
-		llvmType := b.getLLVMType(typ)
+		llvmType := c.getLLVMType(typ)
 		return llvm.ConstNull(llvmType)
 	default:
 		panic("unknown constant: " + expr.String())
@@ -3,13 +3,12 @@ package compiler
 import (
 	"flag"
 	"go/types"
-	"io/ioutil"
+	"os"
 	"strconv"
 	"strings"
 	"testing"

 	"github.com/tinygo-org/tinygo/compileopts"
-	"github.com/tinygo-org/tinygo/goenv"
 	"github.com/tinygo-org/tinygo/loader"
 	"tinygo.org/x/go-llvm"
 )
@@ -28,25 +27,6 @@ type testCase struct {
 func TestCompiler(t *testing.T) {
 	t.Parallel()

-	// Check LLVM version.
-	llvmMajor, err := strconv.Atoi(strings.SplitN(llvm.Version, ".", 2)[0])
-	if err != nil {
-		t.Fatal("could not parse LLVM version:", llvm.Version)
-	}
-	if llvmMajor < 11 {
-		// It is likely this version needs to be bumped in the future.
-		// The goal is to at least test the LLVM version that's used by default
-		// in TinyGo and (if possible without too many workarounds) also some
-		// previous versions.
-		t.Skip("compiler tests require LLVM 11 or above, got LLVM ", llvm.Version)
-	}
-
-	// Determine Go minor version (e.g. 16 in go1.16.3).
-	_, goMinor, err := goenv.GetGorootVersion(goenv.Get("GOROOT"))
-	if err != nil {
-		t.Fatal("could not read Go version:", err)
-	}
-
 	// Determine which tests to run, depending on the Go and LLVM versions.
 	tests := []testCase{
 		{"basic.go", "", ""},
@@ -56,21 +36,13 @@ func TestCompiler(t *testing.T) {
 		{"float.go", "", ""},
 		{"interface.go", "", ""},
 		{"func.go", "", ""},
+		{"defer.go", "cortex-m-qemu", ""},
 		{"pragma.go", "", ""},
 		{"goroutine.go", "wasm", "asyncify"},
 		{"goroutine.go", "cortex-m-qemu", "tasks"},
 		{"channel.go", "", ""},
-		{"intrinsics.go", "cortex-m-qemu", ""},
-		{"intrinsics.go", "wasm", ""},
 		{"gc.go", "", ""},
 	}
-	if llvmMajor >= 12 {
-		tests = append(tests, testCase{"intrinsics.go", "cortex-m-qemu", ""})
-		tests = append(tests, testCase{"intrinsics.go", "wasm", ""})
-	}
-	if goMinor >= 17 {
-		tests = append(tests, testCase{"go1.17.go", "", ""})
-	}

 	for _, tc := range tests {
 		name := tc.file
@@ -100,6 +72,7 @@ func TestCompiler(t *testing.T) {
 			}
 			compilerConfig := &Config{
 				Triple:             config.Triple(),
+				Features:           config.Features(),
 				GOOS:               config.GOOS(),
 				GOARCH:             config.GOARCH(),
 				CodeModel:          config.CodeModel(),
@@ -113,9 +86,10 @@ func TestCompiler(t *testing.T) {
 			if err != nil {
 				t.Fatal("failed to create target machine:", err)
 			}
+			defer machine.Dispose()

 			// Load entire program AST into memory.
-			lprogram, err := loader.Load(config, []string{"./testdata/" + tc.file}, config.ClangHeaders, types.Config{
+			lprogram, err := loader.Load(config, "./testdata/"+tc.file, config.ClangHeaders, types.Config{
 				Sizes: Sizes(machine),
 			})
 			if err != nil {
@@ -163,14 +137,14 @@ func TestCompiler(t *testing.T) {

 			// Update test if needed. Do not check the result.
 			if *flagUpdate {
-				err := ioutil.WriteFile(outPath, []byte(mod.String()), 0666)
+				err := os.WriteFile(outPath, []byte(mod.String()), 0666)
 				if err != nil {
 					t.Error("failed to write updated output file:", err)
 				}
 				return
 			}

-			expected, err := ioutil.ReadFile(outPath)
+			expected, err := os.ReadFile(outPath)
 			if err != nil {
 				t.Fatal("failed to read golden file:", err)
 			}
@@ -221,14 +195,9 @@ 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 = ") {
+		if llvmVersion < 14 && strings.HasPrefix(line, "target datalayout = ") {
 			// The datalayout string may vary betewen LLVM versions.
-			// Right now test outputs are for LLVM 13 and higher.
+			// Right now test outputs are for LLVM 14 and higher.
 			continue
 		}
 		out = append(out, line)
@@ -15,12 +15,39 @@ package compiler

 import (
 	"go/types"
+	"strconv"

 	"github.com/tinygo-org/tinygo/compiler/llvmutil"
 	"golang.org/x/tools/go/ssa"
 	"tinygo.org/x/go-llvm"
 )

+// supportsRecover returns whether the compiler supports the recover() builtin
+// for the current architecture.
+func (b *builder) supportsRecover() bool {
+	switch b.archFamily() {
+	case "wasm32":
+		// Probably needs to be implemented using the exception handling
+		// proposal of WebAssembly:
+		// https://github.com/WebAssembly/exception-handling
+		return false
+	case "riscv64", "xtensa":
+		// TODO: add support for these architectures
+		return false
+	default:
+		return true
+	}
+}
+
+// hasDeferFrame returns whether the current function needs to catch panics and
+// run defers.
+func (b *builder) hasDeferFrame() bool {
+	if b.fn.Recover == nil {
+		return false
+	}
+	return b.supportsRecover()
+}
+
 // deferInitFunc sets up this function for future deferred calls. It must be
 // called from within the entry block when this function contains deferred
 // calls.
@@ -36,6 +63,151 @@ func (b *builder) deferInitFunc() {
 	deferType := llvm.PointerType(b.getLLVMRuntimeType("_defer"), 0)
 	b.deferPtr = b.CreateAlloca(deferType, "deferPtr")
 	b.CreateStore(llvm.ConstPointerNull(deferType), b.deferPtr)
+
+	if b.hasDeferFrame() {
+		// Set up the defer frame with the current stack pointer.
+		// This assumes that the stack pointer doesn't move outside of the
+		// function prologue/epilogue (an invariant maintained by TinyGo but
+		// possibly broken by the C alloca function).
+		// The frame pointer is _not_ saved, because it is marked as clobbered
+		// in the setjmp-like inline assembly.
+		deferFrameType := b.getLLVMRuntimeType("deferFrame")
+		b.deferFrame = b.CreateAlloca(deferFrameType, "deferframe.buf")
+		stackPointer := b.readStackPointer()
+		b.createRuntimeCall("setupDeferFrame", []llvm.Value{b.deferFrame, stackPointer}, "")
+
+		// Create the landing pad block, which is where control transfers after
+		// a panic.
+		b.landingpad = b.ctx.AddBasicBlock(b.llvmFn, "lpad")
+	}
+}
+
+// createLandingPad fills in the landing pad block. This block runs the deferred
+// functions and returns (by jumping to the recover block). If the function is
+// still panicking after the defers are run, the panic will be re-raised in
+// destroyDeferFrame.
+func (b *builder) createLandingPad() {
+	b.SetInsertPointAtEnd(b.landingpad)
+
+	// Add debug info, if needed.
+	// The location used is the closing bracket of the function.
+	if b.Debug {
+		pos := b.program.Fset.Position(b.fn.Syntax().End())
+		b.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), b.difunc, llvm.Metadata{})
+	}
+
+	b.createRunDefers()
+
+	// Continue at the 'recover' block, which returns to the parent in an
+	// appropriate way.
+	b.CreateBr(b.blockEntries[b.fn.Recover])
+}
+
+// createInvokeCheckpoint saves the function state at the given point, to
+// continue at the landing pad if a panic happened. This is implemented using a
+// setjmp-like construct.
+func (b *builder) createInvokeCheckpoint() {
+	// Construct inline assembly equivalents of setjmp.
+	// The assembly works as follows:
+	//   * All registers (both callee-saved and caller saved) are clobbered
+	//     after the inline assembly returns.
+	//   * The assembly stores the address just past the end of the assembly
+	//     into the jump buffer.
+	//   * The return value (eax, rax, r0, etc) is set to zero in the inline
+	//     assembly but set to an unspecified non-zero value when jumping using
+	//     a longjmp.
+	var asmString, constraints string
+	resultType := b.uintptrType
+	switch b.archFamily() {
+	case "i386":
+		asmString = `
+xorl %eax, %eax
+movl $$1f, 4(%ebx)
+1:`
+		constraints = "={eax},{ebx},~{ebx},~{ecx},~{edx},~{esi},~{edi},~{ebp},~{xmm0},~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{fpsr},~{fpcr},~{flags},~{dirflag},~{memory}"
+		// This doesn't include the floating point stack because TinyGo uses
+		// newer floating point instructions.
+	case "x86_64":
+		asmString = `
+leaq 1f(%rip), %rax
+movq %rax, 8(%rbx)
+xorq %rax, %rax
+1:`
+		constraints = "={rax},{rbx},~{rbx},~{rcx},~{rdx},~{rsi},~{rdi},~{rbp},~{r8},~{r9},~{r10},~{r11},~{r12},~{r13},~{r14},~{r15},~{xmm0},~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{xmm8},~{xmm9},~{xmm10},~{xmm11},~{xmm12},~{xmm13},~{xmm14},~{xmm15},~{xmm16},~{xmm17},~{xmm18},~{xmm19},~{xmm20},~{xmm21},~{xmm22},~{xmm23},~{xmm24},~{xmm25},~{xmm26},~{xmm27},~{xmm28},~{xmm29},~{xmm30},~{xmm31},~{fpsr},~{fpcr},~{flags},~{dirflag},~{memory}"
+		// This list doesn't include AVX/AVX512 registers because TinyGo
+		// doesn't currently enable support for AVX instructions.
+	case "arm":
+		// Note: the following assembly takes into account that the PC is
+		// always 4 bytes ahead on ARM. The PC that is stored always points
+		// to the instruction just after the assembly fragment so that
+		// tinygo_longjmp lands at the correct instruction.
+		if b.isThumb() {
+			// Instructions are 2 bytes in size.
+			asmString = `
+movs r0, #0
+mov r2, pc
+str r2, [r1, #4]`
+		} else {
+			// Instructions are 4 bytes in size.
+			asmString = `
+str pc, [r1, #4]
+movs r0, #0`
+		}
+		constraints = "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"
+	case "aarch64":
+		asmString = `
+adr x2, 1f
+str x2, [x1, #8]
+mov x0, #0
+1:
+`
+		constraints = "={x0},{x1},~{x1},~{x2},~{x3},~{x4},~{x5},~{x6},~{x7},~{x8},~{x9},~{x10},~{x11},~{x12},~{x13},~{x14},~{x15},~{x16},~{x17},~{x19},~{x20},~{x21},~{x22},~{x23},~{x24},~{x25},~{x26},~{x27},~{x28},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{q16},~{q17},~{q18},~{q19},~{q20},~{q21},~{q22},~{q23},~{q24},~{q25},~{q26},~{q27},~{q28},~{q29},~{q30},~{nzcv},~{ffr},~{vg},~{memory}"
+		if b.GOOS != "darwin" {
+			// These registers cause the following warning when compiling for
+			// MacOS:
+			//     warning: inline asm clobber list contains reserved registers:
+			//     X18, FP
+			//     Reserved registers on the clobber list may not be preserved
+			//     across the asm statement, and clobbering them may lead to
+			//     undefined behaviour.
+			constraints += ",~{x18},~{fp}"
+		}
+		// TODO: SVE registers, which we don't use in TinyGo at the moment.
+	case "avr":
+		// Note: the Y register (R28:R29) is a fixed register and therefore
+		// needs to be saved manually. TODO: do this only once per function with
+		// a defer frame, not for every call.
+		resultType = b.ctx.Int8Type()
+		asmString = `
+ldi r24, pm_lo8(1f)
+ldi r25, pm_hi8(1f)
+std z+2, r24
+std z+3, r25
+std z+4, r28
+std z+5, r29
+ldi r24, 0
+1:`
+		constraints = "={r24},z,~{r0},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{r13},~{r14},~{r15},~{r16},~{r17},~{r18},~{r19},~{r20},~{r21},~{r22},~{r23},~{r25},~{r26},~{r27}"
+	case "riscv32":
+		asmString = `
+la a2, 1f
+sw a2, 4(a1)
+li a0, 0
+1:`
+		constraints = "={a0},{a1},~{a1},~{a2},~{a3},~{a4},~{a5},~{a6},~{a7},~{s0},~{s1},~{s2},~{s3},~{s4},~{s5},~{s6},~{s7},~{s8},~{s9},~{s10},~{s11},~{t0},~{t1},~{t2},~{t3},~{t4},~{t5},~{t6},~{ra},~{f0},~{f1},~{f2},~{f3},~{f4},~{f5},~{f6},~{f7},~{f8},~{f9},~{f10},~{f11},~{f12},~{f13},~{f14},~{f15},~{f16},~{f17},~{f18},~{f19},~{f20},~{f21},~{f22},~{f23},~{f24},~{f25},~{f26},~{f27},~{f28},~{f29},~{f30},~{f31},~{memory}"
+	default:
+		// This case should have been handled by b.supportsRecover().
+		b.addError(b.fn.Pos(), "unknown architecture for defer: "+b.archFamily())
+	}
+	asmType := llvm.FunctionType(resultType, []llvm.Type{b.deferFrame.Type()}, false)
+	asm := llvm.InlineAsm(asmType, asmString, constraints, false, false, 0, false)
+	result := b.CreateCall(asm, []llvm.Value{b.deferFrame}, "setjmp")
+	result.AddCallSiteAttribute(-1, b.ctx.CreateEnumAttribute(llvm.AttributeKindID("returns_twice"), 0))
+	isZero := b.CreateICmp(llvm.IntEQ, result, llvm.ConstInt(resultType, 0, false), "setjmp.result")
+	continueBB := b.insertBasicBlock("")
+	b.CreateCondBr(isZero, continueBB, b.landingpad)
+	b.SetInsertPointAtEnd(continueBB)
+	b.blockExits[b.currentBlock] = continueBB
 }

 // isInLoop checks if there is a path from a basic block to itself.
@@ -201,30 +373,31 @@ func (b *builder) createDefer(instr *ssa.Defer) {
 		}
 	}

-	// Make a struct out of the collected values to put in the defer frame.
-	deferFrameType := b.ctx.StructType(valueTypes, false)
-	deferFrame := llvm.ConstNull(deferFrameType)
+	// Make a struct out of the collected values to put in the deferred call
+	// struct.
+	deferredCallType := b.ctx.StructType(valueTypes, false)
+	deferredCall := llvm.ConstNull(deferredCallType)
 	for i, value := range values {
-		deferFrame = b.CreateInsertValue(deferFrame, value, i, "")
+		deferredCall = b.CreateInsertValue(deferredCall, value, i, "")
 	}

 	// Put this struct in an allocation.
 	var alloca llvm.Value
 	if !isInLoop(instr.Block()) {
 		// This can safely use a stack allocation.
-		alloca = llvmutil.CreateEntryBlockAlloca(b.Builder, deferFrameType, "defer.alloca")
+		alloca = llvmutil.CreateEntryBlockAlloca(b.Builder, deferredCallType, "defer.alloca")
 	} else {
 		// This may be hit a variable number of times, so use a heap allocation.
-		size := b.targetData.TypeAllocSize(deferFrameType)
+		size := b.targetData.TypeAllocSize(deferredCallType)
 		sizeValue := llvm.ConstInt(b.uintptrType, size, false)
 		nilPtr := llvm.ConstNull(b.i8ptrType)
 		allocCall := b.createRuntimeCall("alloc", []llvm.Value{sizeValue, nilPtr}, "defer.alloc.call")
-		alloca = b.CreateBitCast(allocCall, llvm.PointerType(deferFrameType, 0), "defer.alloc")
+		alloca = b.CreateBitCast(allocCall, llvm.PointerType(deferredCallType, 0), "defer.alloc")
 	}
 	if b.NeedsStackObjects {
 		b.trackPointer(alloca)
 	}
-	b.CreateStore(deferFrame, alloca)
+	b.CreateStore(deferredCall, alloca)

 	// Push it on top of the linked list by replacing deferPtr.
 	allocaCast := b.CreateBitCast(alloca, next.Type(), "defer.alloca.cast")
@@ -248,11 +421,11 @@ func (b *builder) createRunDefers() {
 	//         }
 	//     }

-	// Create loop.
-	loophead := b.ctx.AddBasicBlock(b.llvmFn, "rundefers.loophead")
-	loop := b.ctx.AddBasicBlock(b.llvmFn, "rundefers.loop")
-	unreachable := b.ctx.AddBasicBlock(b.llvmFn, "rundefers.default")
-	end := b.ctx.AddBasicBlock(b.llvmFn, "rundefers.end")
+	// Create loop, in the order: loophead, loop, callback0, callback1, ..., unreachable, end.
+	end := b.insertBasicBlock("rundefers.end")
+	unreachable := b.ctx.InsertBasicBlock(end, "rundefers.default")
+	loop := b.ctx.InsertBasicBlock(unreachable, "rundefers.loop")
+	loophead := b.ctx.InsertBasicBlock(loop, "rundefers.loophead")
 	b.CreateBr(loophead)

 	// Create loop head:
@@ -284,7 +457,7 @@ func (b *builder) createRunDefers() {
 		// Create switch case, for example:
 		//     case 0:
 		//         // run first deferred call
-		block := b.ctx.AddBasicBlock(b.llvmFn, "rundefers.callback")
+		block := b.insertBasicBlock("rundefers.callback" + strconv.Itoa(i))
 		sw.AddCase(llvm.ConstInt(b.uintptrType, uint64(i), false), block)
 		b.SetInsertPointAtEnd(block)
 		switch callback := callback.(type) {
@@ -295,7 +468,7 @@ func (b *builder) createRunDefers() {
 			valueTypes := []llvm.Type{b.uintptrType, llvm.PointerType(b.getLLVMRuntimeType("_defer"), 0)}

 			if !callback.IsInvoke() {
-				//Expect funcValue to be passed through the defer frame.
+				//Expect funcValue to be passed through the deferred call.
 				valueTypes = append(valueTypes, b.getFuncType(callback.Signature()))
 			} else {
 				//Expect typecode
@@ -306,14 +479,14 @@ func (b *builder) createRunDefers() {
 				valueTypes = append(valueTypes, b.getLLVMType(arg.Type()))
 			}

-			deferFrameType := b.ctx.StructType(valueTypes, false)
-			deferFramePtr := b.CreateBitCast(deferData, llvm.PointerType(deferFrameType, 0), "deferFrame")
+			deferredCallType := b.ctx.StructType(valueTypes, false)
+			deferredCallPtr := b.CreateBitCast(deferData, llvm.PointerType(deferredCallType, 0), "defercall")

 			// Extract the params from the struct (including receiver).
 			forwardParams := []llvm.Value{}
 			zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
 			for i := 2; i < len(valueTypes); i++ {
-				gep := b.CreateInBoundsGEP(deferFramePtr, []llvm.Value{zero, llvm.ConstInt(b.ctx.Int32Type(), uint64(i), false)}, "gep")
+				gep := b.CreateInBoundsGEP(deferredCallPtr, []llvm.Value{zero, llvm.ConstInt(b.ctx.Int32Type(), uint64(i), false)}, "gep")
 				forwardParam := b.CreateLoad(gep, "param")
 				forwardParams = append(forwardParams, forwardParam)
 			}
@@ -353,14 +526,14 @@ func (b *builder) createRunDefers() {
 			for _, param := range getParams(callback.Signature) {
 				valueTypes = append(valueTypes, b.getLLVMType(param.Type()))
 			}
-			deferFrameType := b.ctx.StructType(valueTypes, false)
-			deferFramePtr := b.CreateBitCast(deferData, llvm.PointerType(deferFrameType, 0), "deferFrame")
+			deferredCallType := b.ctx.StructType(valueTypes, false)
+			deferredCallPtr := b.CreateBitCast(deferData, llvm.PointerType(deferredCallType, 0), "defercall")

 			// Extract the params from the struct.
 			forwardParams := []llvm.Value{}
 			zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
 			for i := range getParams(callback.Signature) {
-				gep := b.CreateInBoundsGEP(deferFramePtr, []llvm.Value{zero, llvm.ConstInt(b.ctx.Int32Type(), uint64(i+2), false)}, "gep")
+				gep := b.CreateInBoundsGEP(deferredCallPtr, []llvm.Value{zero, llvm.ConstInt(b.ctx.Int32Type(), uint64(i+2), false)}, "gep")
 				forwardParam := b.CreateLoad(gep, "param")
 				forwardParams = append(forwardParams, forwardParam)
 			}
@@ -374,7 +547,7 @@ func (b *builder) createRunDefers() {
 			}

 			// Call real function.
-			b.createCall(b.getFunction(callback), forwardParams, "")
+			b.createInvoke(b.getFunction(callback), forwardParams, "")

 		case *ssa.MakeClosure:
 			// Get the real defer struct type and cast to it.
@@ -385,14 +558,14 @@ func (b *builder) createRunDefers() {
 				valueTypes = append(valueTypes, b.getLLVMType(params.At(i).Type()))
 			}
 			valueTypes = append(valueTypes, b.i8ptrType) // closure
-			deferFrameType := b.ctx.StructType(valueTypes, false)
-			deferFramePtr := b.CreateBitCast(deferData, llvm.PointerType(deferFrameType, 0), "deferFrame")
+			deferredCallType := b.ctx.StructType(valueTypes, false)
+			deferredCallPtr := b.CreateBitCast(deferData, llvm.PointerType(deferredCallType, 0), "defercall")

 			// Extract the params from the struct.
 			forwardParams := []llvm.Value{}
 			zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
 			for i := 2; i < len(valueTypes); i++ {
-				gep := b.CreateInBoundsGEP(deferFramePtr, []llvm.Value{zero, llvm.ConstInt(b.ctx.Int32Type(), uint64(i), false)}, "")
+				gep := b.CreateInBoundsGEP(deferredCallPtr, []llvm.Value{zero, llvm.ConstInt(b.ctx.Int32Type(), uint64(i), false)}, "")
 				forwardParam := b.CreateLoad(gep, "param")
 				forwardParams = append(forwardParams, forwardParam)
 			}
@@ -411,14 +584,14 @@ func (b *builder) createRunDefers() {
 				valueTypes = append(valueTypes, b.getLLVMType(params.At(i).Type()))
 			}

-			deferFrameType := b.ctx.StructType(valueTypes, false)
-			deferFramePtr := b.CreateBitCast(deferData, llvm.PointerType(deferFrameType, 0), "deferFrame")
+			deferredCallType := b.ctx.StructType(valueTypes, false)
+			deferredCallPtr := b.CreateBitCast(deferData, llvm.PointerType(deferredCallType, 0), "defercall")

 			// Extract the params from the struct.
 			var argValues []llvm.Value
 			zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
 			for i := 0; i < params.Len(); i++ {
-				gep := b.CreateInBoundsGEP(deferFramePtr, []llvm.Value{zero, llvm.ConstInt(b.ctx.Int32Type(), uint64(i+2), false)}, "gep")
+				gep := b.CreateInBoundsGEP(deferredCallPtr, []llvm.Value{zero, llvm.ConstInt(b.ctx.Int32Type(), uint64(i+2), false)}, "gep")
 				forwardParam := b.CreateLoad(gep, "param")
 				argValues = append(argValues, forwardParam)
 			}
@@ -120,16 +120,16 @@ func (b *builder) createGo(instr *ssa.Go) {
 // createGoroutineStartWrapper creates a wrapper for the task-based
 // implementation of goroutines. For example, to call a function like this:
 //
-//     func add(x, y int) int { ... }
+//	func add(x, y int) int { ... }
 //
 // It creates a wrapper like this:
 //
-//     func add$gowrapper(ptr *unsafe.Pointer) {
-//         args := (*struct{
-//             x, y int
-//         })(ptr)
-//         add(args.x, args.y)
-//     }
+//	func add$gowrapper(ptr *unsafe.Pointer) {
+//	    args := (*struct{
+//	        x, y int
+//	    })(ptr)
+//	    add(args.x, args.y)
+//	}
 //
 // This is useful because the task-based goroutine start implementation only
 // allows a single (pointer) argument to the newly started goroutine. Also, it
@@ -17,7 +17,7 @@ import (
 // operands or return values. It is useful for trivial instructions, like wfi in
 // ARM or sleep in AVR.
 //
-//     func Asm(asm string)
+//	func Asm(asm string)
 //
 // The provided assembly must be a constant.
 func (b *builder) createInlineAsm(args []ssa.Value) (llvm.Value, error) {
@@ -31,17 +31,17 @@ func (b *builder) createInlineAsm(args []ssa.Value) (llvm.Value, error) {
 // This is a compiler builtin, which allows assembly to be called in a flexible
 // way.
 //
-//     func AsmFull(asm string, regs map[string]interface{}) uintptr
+//	func AsmFull(asm string, regs map[string]interface{}) uintptr
 //
 // The asm parameter must be a constant string. The regs parameter must be
 // provided immediately. For example:
 //
-//     arm.AsmFull(
-//         "str {value}, {result}",
-//         map[string]interface{}{
-//             "value":  1
-//             "result": &dest,
-//         })
+//	arm.AsmFull(
+//	    "str {value}, {result}",
+//	    map[string]interface{}{
+//	        "value":  1
+//	        "result": &dest,
+//	    })
 func (b *builder) createInlineAsmFull(instr *ssa.CallCommon) (llvm.Value, error) {
 	asmString := constant.StringVal(instr.Args[0].(*ssa.Const).Value)
 	registers := map[string]llvm.Value{}
@@ -98,7 +98,10 @@ func (b *builder) createInlineAsmFull(instr *ssa.CallCommon) (llvm.Value, error)
 			case llvm.IntegerTypeKind:
 				constraints = append(constraints, "r")
 			case llvm.PointerTypeKind:
-				constraints = append(constraints, "*m")
+				// Memory references require a type in LLVM 14, probably as a
+				// preparation for opaque pointers.
+				err = b.makeError(instr.Pos(), "support for pointer operands was dropped in TinyGo 0.23")
+				return s
 			default:
 				err = b.makeError(instr.Pos(), "unknown type in inline assembly for value: "+name)
 				return s
@@ -129,11 +132,11 @@ func (b *builder) createInlineAsmFull(instr *ssa.CallCommon) (llvm.Value, error)
 // This is a compiler builtin which emits an inline SVCall instruction. It can
 // be one of:
 //
-//     func SVCall0(num uintptr) uintptr
-//     func SVCall1(num uintptr, a1 interface{}) uintptr
-//     func SVCall2(num uintptr, a1, a2 interface{}) uintptr
-//     func SVCall3(num uintptr, a1, a2, a3 interface{}) uintptr
-//     func SVCall4(num uintptr, a1, a2, a3, a4 interface{}) uintptr
+//	func SVCall0(num uintptr) uintptr
+//	func SVCall1(num uintptr, a1 interface{}) uintptr
+//	func SVCall2(num uintptr, a1, a2 interface{}) uintptr
+//	func SVCall3(num uintptr, a1, a2, a3 interface{}) uintptr
+//	func SVCall4(num uintptr, a1, a2, a3, a4 interface{}) uintptr
 //
 // The num parameter must be a constant. All other parameters may be any scalar
 // value supported by LLVM inline assembly.
@@ -166,11 +169,11 @@ func (b *builder) emitSVCall(args []ssa.Value) (llvm.Value, error) {
 // This is a compiler builtin which emits an inline SVCall instruction. It can
 // be one of:
 //
-//     func SVCall0(num uintptr) uintptr
-//     func SVCall1(num uintptr, a1 interface{}) uintptr
-//     func SVCall2(num uintptr, a1, a2 interface{}) uintptr
-//     func SVCall3(num uintptr, a1, a2, a3 interface{}) uintptr
-//     func SVCall4(num uintptr, a1, a2, a3, a4 interface{}) uintptr
+//	func SVCall0(num uintptr) uintptr
+//	func SVCall1(num uintptr, a1 interface{}) uintptr
+//	func SVCall2(num uintptr, a1, a2 interface{}) uintptr
+//	func SVCall3(num uintptr, a1, a2, a3 interface{}) uintptr
+//	func SVCall4(num uintptr, a1, a2, a3, a4 interface{}) uintptr
 //
 // The num parameter must be a constant. All other parameters may be any scalar
 // value supported by LLVM inline assembly.
@@ -203,10 +206,10 @@ func (b *builder) emitSV64Call(args []ssa.Value) (llvm.Value, error) {

 // This is a compiler builtin which emits CSR instructions. It can be one of:
 //
-//     func (csr CSR) Get() uintptr
-//     func (csr CSR) Set(uintptr)
-//     func (csr CSR) SetBits(uintptr) uintptr
-//     func (csr CSR) ClearBits(uintptr) uintptr
+//	func (csr CSR) Get() uintptr
+//	func (csr CSR) Set(uintptr)
+//	func (csr CSR) SetBits(uintptr) uintptr
+//	func (csr CSR) ClearBits(uintptr) uintptr
 //
 // The csr parameter (method receiver) must be a constant. Other parameter can
 // be any value.
@@ -152,6 +152,27 @@ func (c *compilerContext) makeStructTypeFields(typ *types.Struct) llvm.Value {
 	return structGlobal
 }

+var basicTypes = [...]string{
+	types.Bool:          "bool",
+	types.Int:           "int",
+	types.Int8:          "int8",
+	types.Int16:         "int16",
+	types.Int32:         "int32",
+	types.Int64:         "int64",
+	types.Uint:          "uint",
+	types.Uint8:         "uint8",
+	types.Uint16:        "uint16",
+	types.Uint32:        "uint32",
+	types.Uint64:        "uint64",
+	types.Uintptr:       "uintptr",
+	types.Float32:       "float32",
+	types.Float64:       "float64",
+	types.Complex64:     "complex64",
+	types.Complex128:    "complex128",
+	types.String:        "string",
+	types.UnsafePointer: "unsafe.Pointer",
+}
+
 // getTypeCodeName returns a name for this type that can be used in the
 // interface lowering pass to assign type codes as expected by the reflect
 // package. See getTypeCodeNum.
@@ -162,48 +183,7 @@ func getTypeCodeName(t types.Type) string {
 	case *types.Array:
 		return "array:" + strconv.FormatInt(t.Len(), 10) + ":" + getTypeCodeName(t.Elem())
 	case *types.Basic:
-		var kind string
-		switch t.Kind() {
-		case types.Bool:
-			kind = "bool"
-		case types.Int:
-			kind = "int"
-		case types.Int8:
-			kind = "int8"
-		case types.Int16:
-			kind = "int16"
-		case types.Int32:
-			kind = "int32"
-		case types.Int64:
-			kind = "int64"
-		case types.Uint:
-			kind = "uint"
-		case types.Uint8:
-			kind = "uint8"
-		case types.Uint16:
-			kind = "uint16"
-		case types.Uint32:
-			kind = "uint32"
-		case types.Uint64:
-			kind = "uint64"
-		case types.Uintptr:
-			kind = "uintptr"
-		case types.Float32:
-			kind = "float32"
-		case types.Float64:
-			kind = "float64"
-		case types.Complex64:
-			kind = "complex64"
-		case types.Complex128:
-			kind = "complex128"
-		case types.String:
-			kind = "string"
-		case types.UnsafePointer:
-			kind = "unsafeptr"
-		default:
-			panic("unknown basic type: " + t.Name())
-		}
-		return "basic:" + kind
+		return "basic:" + basicTypes[t.Kind()]
 	case *types.Chan:
 		return "chan:" + getTypeCodeName(t.Elem())
 	case *types.Interface:
@@ -409,8 +389,8 @@ func (b *builder) createTypeAssert(expr *ssa.TypeAssert) llvm.Value {
 	// value.

 	prevBlock := b.GetInsertBlock()
-	okBlock := b.ctx.AddBasicBlock(b.llvmFn, "typeassert.ok")
-	nextBlock := b.ctx.AddBasicBlock(b.llvmFn, "typeassert.next")
+	okBlock := b.insertBasicBlock("typeassert.ok")
+	nextBlock := b.insertBasicBlock("typeassert.next")
 	b.blockExits[b.currentBlock] = nextBlock // adjust outgoing block for phi nodes
 	b.CreateCondBr(commaOk, okBlock, nextBlock)

@@ -570,8 +550,8 @@ func (c *compilerContext) getInterfaceInvokeWrapper(fn *ssa.Function, llvmFn llv
 // internally to match interfaces and to call the correct method on an
 // interface. Examples:
 //
-//     String() string
-//     Read([]byte) (int, error)
+//	String() string
+//	Read([]byte) (int, error)
 func methodSignature(method *types.Func) string {
 	return method.Name() + signature(method.Type().(*types.Signature))
 }
@@ -579,8 +559,8 @@ func methodSignature(method *types.Func) string {
 // Make a readable version of a function (pointer) signature.
 // Examples:
 //
-//     () string
-//     (string, int) (int, error)
+//	() string
+//	(string, int) (int, error)
 func signature(sig *types.Signature) string {
 	s := ""
 	if sig.Params().Len() == 0 {
@@ -591,23 +571,77 @@ func signature(sig *types.Signature) string {
 			if i > 0 {
 				s += ", "
 			}
-			s += sig.Params().At(i).Type().String()
+			s += typestring(sig.Params().At(i).Type())
 		}
 		s += ")"
 	}
 	if sig.Results().Len() == 0 {
 		// keep as-is
 	} else if sig.Results().Len() == 1 {
-		s += " " + sig.Results().At(0).Type().String()
+		s += " " + typestring(sig.Results().At(0).Type())
 	} else {
 		s += " ("
 		for i := 0; i < sig.Results().Len(); i++ {
 			if i > 0 {
 				s += ", "
 			}
-			s += sig.Results().At(i).Type().String()
+			s += typestring(sig.Results().At(i).Type())
 		}
 		s += ")"
 	}
 	return s
 }
+
+// typestring returns a stable (human-readable) type string for the given type
+// that can be used for interface equality checks. It is almost (but not
+// exactly) the same as calling t.String(). The main difference is some
+// normalization around `byte` vs `uint8` for example.
+func typestring(t types.Type) string {
+	// See: https://github.com/golang/go/blob/master/src/go/types/typestring.go
+	switch t := t.(type) {
+	case *types.Array:
+		return "[" + strconv.FormatInt(t.Len(), 10) + "]" + typestring(t.Elem())
+	case *types.Basic:
+		return basicTypes[t.Kind()]
+	case *types.Chan:
+		switch t.Dir() {
+		case types.SendRecv:
+			return "chan (" + typestring(t.Elem()) + ")"
+		case types.SendOnly:
+			return "chan<- (" + typestring(t.Elem()) + ")"
+		case types.RecvOnly:
+			return "<-chan (" + typestring(t.Elem()) + ")"
+		default:
+			panic("unknown channel direction")
+		}
+	case *types.Interface:
+		methods := make([]string, t.NumMethods())
+		for i := range methods {
+			method := t.Method(i)
+			methods[i] = method.Name() + signature(method.Type().(*types.Signature))
+		}
+		return "interface{" + strings.Join(methods, ";") + "}"
+	case *types.Map:
+		return "map[" + typestring(t.Key()) + "]" + typestring(t.Elem())
+	case *types.Named:
+		return t.String()
+	case *types.Pointer:
+		return "*" + typestring(t.Elem())
+	case *types.Signature:
+		return "func" + signature(t)
+	case *types.Slice:
+		return "[]" + typestring(t.Elem())
+	case *types.Struct:
+		fields := make([]string, t.NumFields())
+		for i := range fields {
+			field := t.Field(i)
+			fields[i] = field.Name() + " " + typestring(field.Type())
+			if tag := t.Tag(i); tag != "" {
+				fields[i] += " " + strconv.Quote(tag)
+			}
+		}
+		return "struct{" + strings.Join(fields, ";") + "}"
+	default:
+		panic("unknown type: " + t.String())
+	}
+}
@@ -3,36 +3,67 @@ package compiler
 // This file contains helper functions to create calls to LLVM intrinsics.

 import (
+	"go/token"
 	"strconv"
+	"strings"

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

-// createMemoryCopyCall creates a call to a builtin LLVM memcpy or memmove
+// Define unimplemented intrinsic functions.
+//
+// Some functions are either normally implemented in Go assembly (like
+// sync/atomic functions) or intentionally left undefined to be implemented
+// directly in the compiler (like runtime/volatile functions). Either way, look
+// for these and implement them if this is the case.
+func (b *builder) defineIntrinsicFunction() {
+	name := b.fn.RelString(nil)
+	switch {
+	case name == "runtime.memcpy" || name == "runtime.memmove":
+		b.createMemoryCopyImpl()
+	case name == "runtime.memzero":
+		b.createMemoryZeroImpl()
+	case strings.HasPrefix(name, "runtime/volatile.Load"):
+		b.createVolatileLoad()
+	case strings.HasPrefix(name, "runtime/volatile.Store"):
+		b.createVolatileStore()
+	case strings.HasPrefix(name, "sync/atomic.") && token.IsExported(b.fn.Name()):
+		b.createFunctionStart(true)
+		returnValue := b.createAtomicOp(b.fn.Name())
+		if !returnValue.IsNil() {
+			b.CreateRet(returnValue)
+		} else {
+			b.CreateRetVoid()
+		}
+	}
+}
+
+// createMemoryCopyImpl creates a call to a builtin LLVM memcpy or memmove
 // function, declaring this function if needed. These calls are treated
 // specially by optimization passes possibly resulting in better generated code,
 // and will otherwise be lowered to regular libc memcpy/memmove calls.
-func (b *builder) createMemoryCopyCall(fn *ssa.Function, args []ssa.Value) (llvm.Value, error) {
-	fnName := "llvm." + fn.Name() + ".p0i8.p0i8.i" + strconv.Itoa(b.uintptrType.IntTypeWidth())
+func (b *builder) createMemoryCopyImpl() {
+	b.createFunctionStart(true)
+	fnName := "llvm." + b.fn.Name() + ".p0i8.p0i8.i" + strconv.Itoa(b.uintptrType.IntTypeWidth())
 	llvmFn := b.mod.NamedFunction(fnName)
 	if llvmFn.IsNil() {
 		fnType := llvm.FunctionType(b.ctx.VoidType(), []llvm.Type{b.i8ptrType, b.i8ptrType, b.uintptrType, b.ctx.Int1Type()}, false)
 		llvmFn = llvm.AddFunction(b.mod, fnName, fnType)
 	}
 	var params []llvm.Value
-	for _, param := range args {
+	for _, param := range b.fn.Params {
 		params = append(params, b.getValue(param))
 	}
 	params = append(params, llvm.ConstInt(b.ctx.Int1Type(), 0, false))
 	b.CreateCall(llvmFn, params, "")
-	return llvm.Value{}, nil
+	b.CreateRetVoid()
 }

-// createMemoryZeroCall creates calls to llvm.memset.* to zero a block of
+// createMemoryZeroImpl creates calls to llvm.memset.* to zero a block of
 // memory, declaring the function if needed. These calls will be lowered to
 // regular libc memset calls if they aren't optimized out in a different way.
-func (b *builder) createMemoryZeroCall(args []ssa.Value) (llvm.Value, error) {
+func (b *builder) createMemoryZeroImpl() {
+	b.createFunctionStart(true)
 	fnName := "llvm.memset.p0i8.i" + strconv.Itoa(b.uintptrType.IntTypeWidth())
 	llvmFn := b.mod.NamedFunction(fnName)
 	if llvmFn.IsNil() {
@@ -40,65 +71,54 @@ func (b *builder) createMemoryZeroCall(args []ssa.Value) (llvm.Value, error) {
 		llvmFn = llvm.AddFunction(b.mod, fnName, fnType)
 	}
 	params := []llvm.Value{
-		b.getValue(args[0]),
+		b.getValue(b.fn.Params[0]),
 		llvm.ConstInt(b.ctx.Int8Type(), 0, false),
-		b.getValue(args[1]),
+		b.getValue(b.fn.Params[1]),
 		llvm.ConstInt(b.ctx.Int1Type(), 0, false),
 	}
 	b.CreateCall(llvmFn, params, "")
-	return llvm.Value{}, nil
+	b.CreateRetVoid()
 }

 var mathToLLVMMapping = map[string]string{
-	"math.Sqrt":  "llvm.sqrt.f64",
-	"math.Floor": "llvm.floor.f64",
 	"math.Ceil":  "llvm.ceil.f64",
+	"math.Exp":   "llvm.exp.f64",
+	"math.Exp2":  "llvm.exp2.f64",
+	"math.Floor": "llvm.floor.f64",
+	"math.Log":   "llvm.log.f64",
+	"math.Sqrt":  "llvm.sqrt.f64",
 	"math.Trunc": "llvm.trunc.f64",
 }

-// createMathOp tries to lower the given call as a LLVM math intrinsic, if
-// possible. It returns the call result if possible, and a boolean whether it
-// succeeded. If it doesn't succeed, the architecture doesn't support the given
-// intrinsic.
-func (b *builder) createMathOp(call *ssa.CallCommon) (llvm.Value, bool) {
-	// Check whether this intrinsic is supported on the given GOARCH.
-	// If it is unsupported, this can have two reasons:
-	//
-	//  1. LLVM can expand the intrinsic inline (using float instructions), but
-	//     the result doesn't pass the tests of the math package.
-	//  2. LLVM cannot expand the intrinsic inline, will therefore lower it as a
-	//     libm function call, but the libm function call also fails the math
-	//     package tests.
-	//
-	// Whatever the implementation, it must pass the tests in the math package
-	// so unfortunately only the below intrinsic+architecture combinations are
-	// supported.
-	name := call.StaticCallee().RelString(nil)
-	switch name {
-	case "math.Ceil", "math.Floor", "math.Trunc":
-		if b.GOARCH != "wasm" && b.GOARCH != "arm64" {
-			return llvm.Value{}, false
-		}
-	case "math.Sqrt":
-		if b.GOARCH != "wasm" && b.GOARCH != "amd64" && b.GOARCH != "386" {
-			return llvm.Value{}, false
-		}
-	default:
-		return llvm.Value{}, false // only the above functions are supported.
+// defineMathOp defines a math function body as a call to a LLVM intrinsic,
+// instead of the regular Go implementation. This allows LLVM to reason about
+// the math operation and (depending on the architecture) allows it to lower the
+// operation to very fast floating point instructions. If this is not possible,
+// LLVM will emit a call to a libm function that implements the same operation.
+//
+// One example of an optimization that LLVM can do is to convert
+// float32(math.Sqrt(float64(v))) to a 32-bit floating point operation, which is
+// beneficial on architectures where 64-bit floating point operations are (much)
+// more expensive than 32-bit ones.
+func (b *builder) defineMathOp() {
+	b.createFunctionStart(true)
+	llvmName := mathToLLVMMapping[b.fn.RelString(nil)]
+	if llvmName == "" {
+		panic("unreachable: unknown math operation") // sanity check
 	}
-
-	llvmFn := b.mod.NamedFunction(mathToLLVMMapping[name])
+	llvmFn := b.mod.NamedFunction(llvmName)
 	if llvmFn.IsNil() {
 		// The intrinsic doesn't exist yet, so declare it.
 		// At the moment, all supported intrinsics have the form "double
 		// foo(double %x)" so we can hardcode the signature here.
 		llvmType := llvm.FunctionType(b.ctx.DoubleType(), []llvm.Type{b.ctx.DoubleType()}, false)
-		llvmFn = llvm.AddFunction(b.mod, mathToLLVMMapping[name], llvmType)
+		llvmFn = llvm.AddFunction(b.mod, llvmName, llvmType)
 	}
 	// Create a call to the intrinsic.
-	args := make([]llvm.Value, len(call.Args))
-	for i, arg := range call.Args {
-		args[i] = b.getValue(arg)
+	args := make([]llvm.Value, len(b.fn.Params))
+	for i, param := range b.fn.Params {
+		args[i] = b.getValue(param)
 	}
-	return b.CreateCall(llvmFn, args, ""), true
+	result := b.CreateCall(llvmFn, args, "")
+	b.CreateRet(result)
 }
@@ -31,7 +31,7 @@ func (c *checker) checkType(t llvm.Type, checked map[llvm.Type]struct{}, special
 		return fmt.Errorf("type %q uses global context", t.String())
 	default:
 		// we used some other context by accident
-		return fmt.Errorf("type %q uses context %v instead of the main context %v", t.Context(), c.ctx)
+		return fmt.Errorf("type %q uses context %v instead of the main context %v", t.String(), t.Context(), c.ctx)
 	}

 	// if this is a composite type, check the components of the type
@@ -5,6 +5,7 @@ import (
 	"go/token"
 	"go/types"
 	"math/big"
+	"strings"

 	"github.com/tinygo-org/tinygo/compiler/llvmutil"
 	"tinygo.org/x/go-llvm"
@@ -23,6 +24,23 @@ func (b *builder) createTemporaryAlloca(t llvm.Type, name string) (alloca, bitca
 	return llvmutil.CreateTemporaryAlloca(b.Builder, b.mod, t, name)
 }

+// insertBasicBlock inserts a new basic block after the current basic block.
+// This is useful when inserting new basic blocks while converting a
+// *ssa.BasicBlock to a llvm.BasicBlock and the LLVM basic block needs some
+// extra blocks.
+// It does not update b.blockExits, this must be done by the caller.
+func (b *builder) insertBasicBlock(name string) llvm.BasicBlock {
+	currentBB := b.Builder.GetInsertBlock()
+	nextBB := llvm.NextBasicBlock(currentBB)
+	if nextBB.IsNil() {
+		// Last basic block in the function, so add one to the end.
+		return b.ctx.AddBasicBlock(b.llvmFn, name)
+	}
+	// Insert a basic block before the next basic block - that is, at the
+	// current insert location.
+	return b.ctx.InsertBasicBlock(nextBB, name)
+}
+
 // emitLifetimeEnd signals the end of an (alloca) lifetime by calling the
 // llvm.lifetime.end intrinsic. It is commonly used together with
 // createTemporaryAlloca.
@@ -253,3 +271,46 @@ func (c *compilerContext) getPointerBitmap(typ llvm.Type, pos token.Pos) *big.In
 		panic("unknown LLVM type")
 	}
 }
+
+// archFamily returns the archtecture from the LLVM triple but with some
+// architecture names ("armv6", "thumbv7m", etc) merged into a single
+// architecture name ("arm").
+func (c *compilerContext) archFamily() string {
+	arch := strings.Split(c.Triple, "-")[0]
+	if strings.HasPrefix(arch, "arm64") {
+		return "aarch64"
+	}
+	if strings.HasPrefix(arch, "arm") || strings.HasPrefix(arch, "thumb") {
+		return "arm"
+	}
+	return arch
+}
+
+// isThumb returns whether we're in ARM or in Thumb mode. It panics if the
+// features string is not one for an ARM architecture.
+func (c *compilerContext) isThumb() bool {
+	var isThumb, isNotThumb bool
+	for _, feature := range strings.Split(c.Features, ",") {
+		if feature == "+thumb-mode" {
+			isThumb = true
+		}
+		if feature == "-thumb-mode" {
+			isNotThumb = true
+		}
+	}
+	if isThumb == isNotThumb {
+		panic("unexpected feature flags")
+	}
+	return isThumb
+}
+
+// readStackPointer emits a LLVM intrinsic call that returns the current stack
+// pointer as an *i8.
+func (b *builder) readStackPointer() llvm.Value {
+	stacksave := b.mod.NamedFunction("llvm.stacksave")
+	if stacksave.IsNil() {
+		fnType := llvm.FunctionType(b.i8ptrType, nil, false)
+		stacksave = llvm.AddFunction(b.mod, "llvm.stacksave", fnType)
+	}
+	return b.CreateCall(stacksave, nil, "")
+}
@@ -34,6 +34,7 @@ func CreateEntryBlockAlloca(builder llvm.Builder, t llvm.Type, name string) llvm
 func CreateTemporaryAlloca(builder llvm.Builder, mod llvm.Module, t llvm.Type, name string) (alloca, bitcast, size llvm.Value) {
 	ctx := t.Context()
 	targetData := llvm.NewTargetData(mod.DataLayout())
+	defer targetData.Dispose()
 	i8ptrType := llvm.PointerType(ctx.Int8Type(), 0)
 	alloca = CreateEntryBlockAlloca(builder, t, name)
 	bitcast = builder.CreateBitCast(alloca, i8ptrType, name+".bitcast")
@@ -46,6 +47,7 @@ func CreateTemporaryAlloca(builder llvm.Builder, mod llvm.Module, t llvm.Type, n
 func CreateInstructionAlloca(builder llvm.Builder, mod llvm.Module, t llvm.Type, inst llvm.Value, name string) llvm.Value {
 	ctx := mod.Context()
 	targetData := llvm.NewTargetData(mod.DataLayout())
+	defer targetData.Dispose()
 	i8ptrType := llvm.PointerType(ctx.Int8Type(), 0)

 	alloca := CreateEntryBlockAlloca(builder, t, name)
@@ -15,8 +15,9 @@ import (
 func EmitPointerPack(builder llvm.Builder, mod llvm.Module, prefix string, needsStackObjects bool, values []llvm.Value) llvm.Value {
 	ctx := mod.Context()
 	targetData := llvm.NewTargetData(mod.DataLayout())
+	defer targetData.Dispose()
 	i8ptrType := llvm.PointerType(mod.Context().Int8Type(), 0)
-	uintptrType := ctx.IntType(llvm.NewTargetData(mod.DataLayout()).PointerSize() * 8)
+	uintptrType := ctx.IntType(targetData.PointerSize() * 8)

 	valueTypes := make([]llvm.Type, len(values))
 	for i, value := range values {
@@ -127,8 +128,9 @@ func EmitPointerPack(builder llvm.Builder, mod llvm.Module, prefix string, needs
 func EmitPointerUnpack(builder llvm.Builder, mod llvm.Module, ptr llvm.Value, valueTypes []llvm.Type) []llvm.Value {
 	ctx := mod.Context()
 	targetData := llvm.NewTargetData(mod.DataLayout())
+	defer targetData.Dispose()
 	i8ptrType := llvm.PointerType(mod.Context().Int8Type(), 0)
-	uintptrType := ctx.IntType(llvm.NewTargetData(mod.DataLayout()).PointerSize() * 8)
+	uintptrType := ctx.IntType(targetData.PointerSize() * 8)

 	packedType := ctx.StructType(valueTypes, false)

@@ -10,6 +10,13 @@ import (
 	"tinygo.org/x/go-llvm"
 )

+// constants for hashmap algorithms; must match src/runtime/hashmap.go
+const (
+	hashmapAlgorithmBinary = iota
+	hashmapAlgorithmString
+	hashmapAlgorithmInterface
+)
+
 // createMakeMap creates a new map object (runtime.hashmap) by allocating and
 // initializing an appropriately sized object.
 func (b *builder) createMakeMap(expr *ssa.MakeMap) (llvm.Value, error) {
@@ -17,22 +24,27 @@ func (b *builder) createMakeMap(expr *ssa.MakeMap) (llvm.Value, error) {
 	keyType := mapType.Key().Underlying()
 	llvmValueType := b.getLLVMType(mapType.Elem().Underlying())
 	var llvmKeyType llvm.Type
+	var alg uint64 // must match values in src/runtime/hashmap.go
 	if t, ok := keyType.(*types.Basic); ok && t.Info()&types.IsString != 0 {
 		// String keys.
 		llvmKeyType = b.getLLVMType(keyType)
+		alg = hashmapAlgorithmString
 	} else if hashmapIsBinaryKey(keyType) {
 		// Trivially comparable keys.
 		llvmKeyType = b.getLLVMType(keyType)
+		alg = hashmapAlgorithmBinary
 	} else {
 		// All other keys. Implemented as map[interface{}]valueType for ease of
 		// implementation.
 		llvmKeyType = b.getLLVMRuntimeType("_interface")
+		alg = hashmapAlgorithmInterface
 	}
 	keySize := b.targetData.TypeAllocSize(llvmKeyType)
 	valueSize := b.targetData.TypeAllocSize(llvmValueType)
 	llvmKeySize := llvm.ConstInt(b.ctx.Int8Type(), keySize, false)
 	llvmValueSize := llvm.ConstInt(b.ctx.Int8Type(), valueSize, false)
 	sizeHint := llvm.ConstInt(b.uintptrType, 8, false)
+	algEnum := llvm.ConstInt(b.ctx.Int8Type(), alg, false)
 	if expr.Reserve != nil {
 		sizeHint = b.getValue(expr.Reserve)
 		var err error
@@ -41,7 +53,7 @@ func (b *builder) createMakeMap(expr *ssa.MakeMap) (llvm.Value, error) {
 			return llvm.Value{}, err
 		}
 	}
-	hashmap := b.createRuntimeCall("hashmapMake", []llvm.Value{llvmKeySize, llvmValueSize, sizeHint}, "")
+	hashmap := b.createRuntimeCall("hashmapMake", []llvm.Value{llvmKeySize, llvmValueSize, sizeHint, algEnum}, "")
 	return hashmap, nil
 }

@@ -45,7 +45,11 @@ func (s *stdSizes) Alignof(T types.Type) int64 {
 		if t.Info()&types.IsString != 0 {
 			return s.PtrSize
 		}
+	case *types.Signature:
+		// Even though functions in tinygo are 2 pointers, they are not 2 pointer aligned
+		return s.PtrSize
 	}
+
 	a := s.Sizeof(T) // may be 0
 	// spec: "For a variable x of any type: unsafe.Alignof(x) is at least 1."
 	if a < 1 {
@@ -148,7 +152,7 @@ func (s *stdSizes) Sizeof(T types.Type) int64 {
 		return align(offsets[n-1]+s.Sizeof(fields[n-1].Type()), maxAlign)
 	case *types.Interface:
 		return s.PtrSize * 2
-	case *types.Pointer:
+	case *types.Pointer, *types.Chan, *types.Map:
 		return s.PtrSize
 	case *types.Signature:
 		// Func values in TinyGo are two words in size.
@@ -163,18 +163,20 @@ func (c *compilerContext) getFunction(fn *ssa.Function) llvm.Value {
 	// External/exported functions may not retain pointer values.
 	// https://golang.org/cmd/cgo/#hdr-Passing_pointers
 	if info.exported {
-		// Set the wasm-import-module attribute if the function's module is set.
-		if info.module != "" {
-
+		if c.archFamily() == "wasm32" {
 			// We need to add the wasm-import-module and the wasm-import-name
-			wasmImportModuleAttr := c.ctx.CreateStringAttribute("wasm-import-module", info.module)
-			llvmFn.AddFunctionAttr(wasmImportModuleAttr)
-
-			// Add the Wasm Import Name, if we are a named wasm import
-			if info.importName != "" {
-				wasmImportNameAttr := c.ctx.CreateStringAttribute("wasm-import-name", info.importName)
-				llvmFn.AddFunctionAttr(wasmImportNameAttr)
+			// attributes.
+			module := info.module
+			if module == "" {
+				module = "env"
 			}
+			llvmFn.AddFunctionAttr(c.ctx.CreateStringAttribute("wasm-import-module", module))
+
+			name := info.importName
+			if name == "" {
+				name = info.linkName
+			}
+			llvmFn.AddFunctionAttr(c.ctx.CreateStringAttribute("wasm-import-name", name))
 		}
 		nocaptureKind := llvm.AttributeKindID("nocapture")
 		nocapture := c.ctx.CreateEnumAttribute(nocaptureKind, 0)
@@ -191,7 +193,7 @@ func (c *compilerContext) getFunction(fn *ssa.Function) llvm.Value {
 	// should be created right away.
 	// The exception is the package initializer, which does appear in the
 	// *ssa.Package members and so shouldn't be created here.
-	if fn.Synthetic != "" && fn.Synthetic != "package initializer" {
+	if fn.Synthetic != "" && fn.Synthetic != "package initializer" && fn.Synthetic != "generic function" {
 		irbuilder := c.ctx.NewBuilder()
 		b := newBuilder(c, irbuilder, fn)
 		b.createFunction()
@@ -16,20 +16,7 @@ import (
 func (b *builder) createRawSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 	num := b.getValue(call.Args[0])
 	switch {
-	case b.GOARCH == "amd64":
-		if b.GOOS == "darwin" {
-			// Darwin adds this magic number to system call numbers:
-			//
-			// > Syscall classes for 64-bit system call entry.
-			// > For 64-bit users, the 32-bit syscall number is partitioned
-			// > with the high-order bits representing the class and low-order
-			// > bits being the syscall number within that class.
-			// > The high-order 32-bits of the 64-bit syscall number are unused.
-			// > All system classes enter the kernel via the syscall instruction.
-			//
-			// Source: https://opensource.apple.com/source/xnu/xnu-792.13.8/osfmk/mach/i386/syscall_sw.h
-			num = b.CreateOr(num, llvm.ConstInt(b.uintptrType, 0x2000000, false), "")
-		}
+	case b.GOARCH == "amd64" && b.GOOS == "linux":
 		// Sources:
 		//   https://stackoverflow.com/a/2538212
 		//   https://en.wikibooks.org/wiki/X86_Assembly/Interfacing_with_Linux#syscall
@@ -179,26 +166,6 @@ func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		retval = b.CreateInsertValue(retval, zero, 1, "")
 		retval = b.CreateInsertValue(retval, errResult, 2, "")
 		return retval, nil
-	case "darwin":
-		syscallResult, err := b.createRawSyscall(call)
-		if err != nil {
-			return syscallResult, err
-		}
-		// Return values: r0, r1 uintptr, err Errno
-		// Pseudocode:
-		//     var err uintptr
-		//     if syscallResult != 0 {
-		//         err = syscallResult
-		//     }
-		//     return syscallResult, 0, err
-		zero := llvm.ConstInt(b.uintptrType, 0, false)
-		hasError := b.CreateICmp(llvm.IntNE, syscallResult, llvm.ConstInt(b.uintptrType, 0, false), "")
-		errResult := b.CreateSelect(hasError, syscallResult, zero, "syscallError")
-		retval := llvm.Undef(b.ctx.StructType([]llvm.Type{b.uintptrType, b.uintptrType, b.uintptrType}, false))
-		retval = b.CreateInsertValue(retval, syscallResult, 0, "")
-		retval = b.CreateInsertValue(retval, zero, 1, "")
-		retval = b.CreateInsertValue(retval, errResult, 2, "")
-		return retval, nil
 	case "windows":
 		// On Windows, syscall.Syscall* is basically just a function pointer
 		// call. This is complicated in gc because of stack switching and the
@@ -1,45 +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-p10:8:8-p20:8:8-i64:64-n32:64-S128-ni:1:10:20"
 target triple = "wasm32-unknown-wasi"

 %main.kv = type { float }
 %main.kv.0 = type { i8 }

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

-declare void @runtime.trackPointer(i8* nocapture readonly, i8*)
+declare void @runtime.trackPointer(i8* nocapture readonly, i8*) #0

 ; Function Attrs: nounwind
-define hidden void @main.init(i8* %context) unnamed_addr #0 {
+define hidden void @main.init(i8* %context) unnamed_addr #1 {
 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) unnamed_addr #1 {
 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) unnamed_addr #1 {
 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) unnamed_addr #1 {
 entry:
  %0 = icmp eq i32 %y, 0
  br i1 %0, label %divbyzero.throw, label %divbyzero.next

-divbyzero.throw:                                  ; preds = %entry
-  call void @runtime.divideByZeroPanic(i8* undef) #0
-  unreachable
-
 divbyzero.next:                                   ; preds = %entry
  %1 = icmp eq i32 %y, -1
  %2 = icmp eq i32 %x, -2147483648
@@ -47,35 +43,35 @@ divbyzero.next:                                   ; preds = %entry
  %4 = select i1 %3, i32 1, i32 %y
  %5 = sdiv i32 %x, %4
  ret i32 %5
+
+divbyzero.throw:                                  ; preds = %entry
+  call void @runtime.divideByZeroPanic(i8* undef) #2
+  unreachable
 }

-declare void @runtime.divideByZeroPanic(i8*)
+declare void @runtime.divideByZeroPanic(i8*) #0

 ; 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) unnamed_addr #1 {
 entry:
  %0 = icmp eq i32 %y, 0
  br i1 %0, label %divbyzero.throw, label %divbyzero.next

-divbyzero.throw:                                  ; preds = %entry
-  call void @runtime.divideByZeroPanic(i8* undef) #0
-  unreachable
-
 divbyzero.next:                                   ; preds = %entry
  %1 = udiv i32 %x, %y
  ret i32 %1
+
+divbyzero.throw:                                  ; preds = %entry
+  call void @runtime.divideByZeroPanic(i8* undef) #2
+  unreachable
 }

 ; 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) unnamed_addr #1 {
 entry:
  %0 = icmp eq i32 %y, 0
  br i1 %0, label %divbyzero.throw, label %divbyzero.next

-divbyzero.throw:                                  ; preds = %entry
-  call void @runtime.divideByZeroPanic(i8* undef) #0
-  unreachable
-
 divbyzero.next:                                   ; preds = %entry
  %1 = icmp eq i32 %y, -1
  %2 = icmp eq i32 %x, -2147483648
@@ -83,79 +79,83 @@ divbyzero.next:                                   ; preds = %entry
  %4 = select i1 %3, i32 1, i32 %y
  %5 = srem i32 %x, %4
  ret i32 %5
+
+divbyzero.throw:                                  ; preds = %entry
+  call void @runtime.divideByZeroPanic(i8* undef) #2
+  unreachable
 }

 ; 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) unnamed_addr #1 {
 entry:
  %0 = icmp eq i32 %y, 0
  br i1 %0, label %divbyzero.throw, label %divbyzero.next

-divbyzero.throw:                                  ; preds = %entry
-  call void @runtime.divideByZeroPanic(i8* undef) #0
-  unreachable
-
 divbyzero.next:                                   ; preds = %entry
  %1 = urem i32 %x, %y
  ret i32 %1
+
+divbyzero.throw:                                  ; preds = %entry
+  call void @runtime.divideByZeroPanic(i8* undef) #2
+  unreachable
 }

 ; 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) unnamed_addr #1 {
 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) unnamed_addr #1 {
 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) unnamed_addr #1 {
 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) unnamed_addr #1 {
 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) unnamed_addr #1 {
 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) unnamed_addr #1 {
 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) unnamed_addr #1 {
 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) unnamed_addr #1 {
 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) unnamed_addr #1 {
 entry:
  %0 = fadd float %x.r, %y.r
  %1 = fadd float %x.i, %y.i
@@ -165,7 +165,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) unnamed_addr #1 {
 entry:
  %0 = fsub float %x.r, %y.r
  %1 = fsub float %x.i, %y.i
@@ -175,7 +175,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) unnamed_addr #1 {
 entry:
  %0 = fmul float %x.r, %y.r
  %1 = fmul float %x.i, %y.i
@@ -189,16 +189,18 @@ 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) unnamed_addr #1 {
 entry:
  call void @"main.foo$1"(%main.kv.0* null, 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 internal void @"main.foo$1"(%main.kv.0* dereferenceable_or_null(1) %b, i8* %context) unnamed_addr #1 {
 entry:
  ret void
 }

-attributes #0 = { nounwind }
+attributes #0 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #1 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #2 = { nounwind }
@@ -1,28 +1,28 @@
 ; 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-p10:8:8-p20:8:8-i64:64-n32:64-S128-ni:1:10:20"
 target triple = "wasm32-unknown-wasi"

 %runtime.channel = type { i32, i32, i8, %runtime.channelBlockedList*, i32, i32, i32, i8* }
 %runtime.channelBlockedList = type { %runtime.channelBlockedList*, %"internal/task.Task"*, %runtime.chanSelectState*, { %runtime.channelBlockedList*, i32, i32 } }
-%"internal/task.Task" = type { %"internal/task.Task"*, i8*, i64, %"internal/task.gcData", %"internal/task.state" }
+%"internal/task.Task" = type { %"internal/task.Task"*, i8*, i64, %"internal/task.gcData", %"internal/task.state", i8* }
 %"internal/task.gcData" = type { i8* }
 %"internal/task.state" = type { i32, i8*, %"internal/task.stackState", i1 }
 %"internal/task.stackState" = type { i32, i32 }
 %runtime.chanSelectState = type { %runtime.channel*, i8* }

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

-declare void @runtime.trackPointer(i8* nocapture readonly, i8*)
+declare void @runtime.trackPointer(i8* nocapture readonly, i8*) #0

 ; Function Attrs: nounwind
-define hidden void @main.init(i8* %context) unnamed_addr #0 {
+define hidden void @main.init(i8* %context) unnamed_addr #1 {
 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) unnamed_addr #1 {
 entry:
  %chan.blockedList = alloca %runtime.channelBlockedList, align 8
  %chan.value = alloca i32, align 4
@@ -31,22 +31,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) #3
  call void @llvm.lifetime.end.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
  call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull %chan.value.bitcast)
  ret void
 }

 ; Function Attrs: argmemonly nofree nosync nounwind willreturn
-declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture) #1
+declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture) #2

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

 ; Function Attrs: argmemonly nofree nosync nounwind willreturn
-declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture) #1
+declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture) #2

 ; 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) unnamed_addr #1 {
 entry:
  %chan.blockedList = alloca %runtime.channelBlockedList, align 8
  %chan.value = alloca i32, align 4
@@ -54,41 +54,41 @@ 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) #3
  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*) #0

 ; 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) unnamed_addr #1 {
 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
+  call void @runtime.trackPointer(i8* nonnull %0, i8* undef) #3
  %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) #3
  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) unnamed_addr #1 {
 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) #3
  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) unnamed_addr #1 {
 entry:
  %select.states.alloca = alloca [2 x %runtime.chanSelectState], align 8
  %select.send.value = alloca i32, align 4
@@ -105,7 +105,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) #3
  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 +122,9 @@ 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*) #0

-attributes #0 = { nounwind }
-attributes #1 = { argmemonly nofree nosync nounwind willreturn }
+attributes #0 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #1 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #2 = { argmemonly nofree nosync nounwind willreturn }
+attributes #3 = { nounwind }
@@ -0,0 +1,266 @@
+; ModuleID = 'defer.go'
+source_filename = "defer.go"
+target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
+target triple = "thumbv7m-unknown-unknown-eabi"
+
+%runtime._defer = type { i32, %runtime._defer* }
+%runtime.deferFrame = type { i8*, i8*, [0 x i8*], %runtime.deferFrame*, i1, %runtime._interface }
+%runtime._interface = type { i32, i8* }
+
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*) #0
+
+; Function Attrs: nounwind
+define hidden void @main.init(i8* %context) unnamed_addr #1 {
+entry:
+  ret void
+}
+
+declare void @main.external(i8*) #0
+
+; Function Attrs: nounwind
+define hidden void @main.deferSimple(i8* %context) unnamed_addr #1 {
+entry:
+  %defer.alloca = alloca { i32, %runtime._defer* }, align 4
+  %deferPtr = alloca %runtime._defer*, align 4
+  store %runtime._defer* null, %runtime._defer** %deferPtr, align 4
+  %deferframe.buf = alloca %runtime.deferFrame, align 4
+  %0 = call i8* @llvm.stacksave()
+  call void @runtime.setupDeferFrame(%runtime.deferFrame* nonnull %deferframe.buf, i8* %0, i8* undef) #3
+  %defer.alloca.repack = getelementptr inbounds { i32, %runtime._defer* }, { i32, %runtime._defer* }* %defer.alloca, i32 0, i32 0
+  store i32 0, i32* %defer.alloca.repack, align 4
+  %defer.alloca.repack16 = getelementptr inbounds { i32, %runtime._defer* }, { i32, %runtime._defer* }* %defer.alloca, i32 0, i32 1
+  store %runtime._defer* null, %runtime._defer** %defer.alloca.repack16, align 4
+  %1 = bitcast %runtime._defer** %deferPtr to { i32, %runtime._defer* }**
+  store { i32, %runtime._defer* }* %defer.alloca, { i32, %runtime._defer* }** %1, align 4
+  %setjmp = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(%runtime.deferFrame* nonnull %deferframe.buf) #4
+  %setjmp.result = icmp eq i32 %setjmp, 0
+  br i1 %setjmp.result, label %2, label %lpad
+
+2:                                                ; preds = %entry
+  call void @main.external(i8* undef) #3
+  br label %rundefers.loophead
+
+rundefers.loophead:                               ; preds = %4, %2
+  %3 = load %runtime._defer*, %runtime._defer** %deferPtr, align 4
+  %stackIsNil = icmp eq %runtime._defer* %3, null
+  br i1 %stackIsNil, label %rundefers.end, label %rundefers.loop
+
+rundefers.loop:                                   ; preds = %rundefers.loophead
+  %stack.next.gep = getelementptr inbounds %runtime._defer, %runtime._defer* %3, i32 0, i32 1
+  %stack.next = load %runtime._defer*, %runtime._defer** %stack.next.gep, align 4
+  store %runtime._defer* %stack.next, %runtime._defer** %deferPtr, align 4
+  %callback.gep = getelementptr inbounds %runtime._defer, %runtime._defer* %3, i32 0, i32 0
+  %callback = load i32, i32* %callback.gep, align 4
+  switch i32 %callback, label %rundefers.default [
+    i32 0, label %rundefers.callback0
+  ]
+
+rundefers.callback0:                              ; preds = %rundefers.loop
+  %setjmp1 = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(%runtime.deferFrame* nonnull %deferframe.buf) #4
+  %setjmp.result2 = icmp eq i32 %setjmp1, 0
+  br i1 %setjmp.result2, label %4, label %lpad
+
+4:                                                ; preds = %rundefers.callback0
+  call void @"main.deferSimple$1"(i8* undef)
+  br label %rundefers.loophead
+
+rundefers.default:                                ; preds = %rundefers.loop
+  unreachable
+
+rundefers.end:                                    ; preds = %rundefers.loophead
+  call void @runtime.destroyDeferFrame(%runtime.deferFrame* nonnull %deferframe.buf, i8* undef) #3
+  ret void
+
+recover:                                          ; preds = %rundefers.end3
+  call void @runtime.destroyDeferFrame(%runtime.deferFrame* nonnull %deferframe.buf, i8* undef) #3
+  ret void
+
+lpad:                                             ; preds = %rundefers.callback012, %rundefers.callback0, %entry
+  br label %rundefers.loophead6
+
+rundefers.loophead6:                              ; preds = %6, %lpad
+  %5 = load %runtime._defer*, %runtime._defer** %deferPtr, align 4
+  %stackIsNil7 = icmp eq %runtime._defer* %5, null
+  br i1 %stackIsNil7, label %rundefers.end3, label %rundefers.loop5
+
+rundefers.loop5:                                  ; preds = %rundefers.loophead6
+  %stack.next.gep8 = getelementptr inbounds %runtime._defer, %runtime._defer* %5, i32 0, i32 1
+  %stack.next9 = load %runtime._defer*, %runtime._defer** %stack.next.gep8, align 4
+  store %runtime._defer* %stack.next9, %runtime._defer** %deferPtr, align 4
+  %callback.gep10 = getelementptr inbounds %runtime._defer, %runtime._defer* %5, i32 0, i32 0
+  %callback11 = load i32, i32* %callback.gep10, align 4
+  switch i32 %callback11, label %rundefers.default4 [
+    i32 0, label %rundefers.callback012
+  ]
+
+rundefers.callback012:                            ; preds = %rundefers.loop5
+  %setjmp14 = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(%runtime.deferFrame* nonnull %deferframe.buf) #4
+  %setjmp.result15 = icmp eq i32 %setjmp14, 0
+  br i1 %setjmp.result15, label %6, label %lpad
+
+6:                                                ; preds = %rundefers.callback012
+  call void @"main.deferSimple$1"(i8* undef)
+  br label %rundefers.loophead6
+
+rundefers.default4:                               ; preds = %rundefers.loop5
+  unreachable
+
+rundefers.end3:                                   ; preds = %rundefers.loophead6
+  br label %recover
+}
+
+; Function Attrs: nofree nosync nounwind willreturn
+declare i8* @llvm.stacksave() #2
+
+declare void @runtime.setupDeferFrame(%runtime.deferFrame* dereferenceable_or_null(24), i8*, i8*) #0
+
+; Function Attrs: nounwind
+define internal void @"main.deferSimple$1"(i8* %context) unnamed_addr #1 {
+entry:
+  call void @runtime.printint32(i32 3, i8* undef) #3
+  ret void
+}
+
+declare void @runtime.destroyDeferFrame(%runtime.deferFrame* dereferenceable_or_null(24), i8*) #0
+
+declare void @runtime.printint32(i32, i8*) #0
+
+; Function Attrs: nounwind
+define hidden void @main.deferMultiple(i8* %context) unnamed_addr #1 {
+entry:
+  %defer.alloca2 = alloca { i32, %runtime._defer* }, align 4
+  %defer.alloca = alloca { i32, %runtime._defer* }, align 4
+  %deferPtr = alloca %runtime._defer*, align 4
+  store %runtime._defer* null, %runtime._defer** %deferPtr, align 4
+  %deferframe.buf = alloca %runtime.deferFrame, align 4
+  %0 = call i8* @llvm.stacksave()
+  call void @runtime.setupDeferFrame(%runtime.deferFrame* nonnull %deferframe.buf, i8* %0, i8* undef) #3
+  %defer.alloca.repack = getelementptr inbounds { i32, %runtime._defer* }, { i32, %runtime._defer* }* %defer.alloca, i32 0, i32 0
+  store i32 0, i32* %defer.alloca.repack, align 4
+  %defer.alloca.repack26 = getelementptr inbounds { i32, %runtime._defer* }, { i32, %runtime._defer* }* %defer.alloca, i32 0, i32 1
+  store %runtime._defer* null, %runtime._defer** %defer.alloca.repack26, align 4
+  %1 = bitcast %runtime._defer** %deferPtr to { i32, %runtime._defer* }**
+  store { i32, %runtime._defer* }* %defer.alloca, { i32, %runtime._defer* }** %1, align 4
+  %defer.alloca2.repack = getelementptr inbounds { i32, %runtime._defer* }, { i32, %runtime._defer* }* %defer.alloca2, i32 0, i32 0
+  store i32 1, i32* %defer.alloca2.repack, align 4
+  %defer.alloca2.repack27 = getelementptr inbounds { i32, %runtime._defer* }, { i32, %runtime._defer* }* %defer.alloca2, i32 0, i32 1
+  %2 = bitcast %runtime._defer** %defer.alloca2.repack27 to { i32, %runtime._defer* }**
+  store { i32, %runtime._defer* }* %defer.alloca, { i32, %runtime._defer* }** %2, align 4
+  %3 = bitcast %runtime._defer** %deferPtr to { i32, %runtime._defer* }**
+  store { i32, %runtime._defer* }* %defer.alloca2, { i32, %runtime._defer* }** %3, align 4
+  %setjmp = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(%runtime.deferFrame* nonnull %deferframe.buf) #4
+  %setjmp.result = icmp eq i32 %setjmp, 0
+  br i1 %setjmp.result, label %4, label %lpad
+
+4:                                                ; preds = %entry
+  call void @main.external(i8* undef) #3
+  br label %rundefers.loophead
+
+rundefers.loophead:                               ; preds = %7, %6, %4
+  %5 = load %runtime._defer*, %runtime._defer** %deferPtr, align 4
+  %stackIsNil = icmp eq %runtime._defer* %5, null
+  br i1 %stackIsNil, label %rundefers.end, label %rundefers.loop
+
+rundefers.loop:                                   ; preds = %rundefers.loophead
+  %stack.next.gep = getelementptr inbounds %runtime._defer, %runtime._defer* %5, i32 0, i32 1
+  %stack.next = load %runtime._defer*, %runtime._defer** %stack.next.gep, align 4
+  store %runtime._defer* %stack.next, %runtime._defer** %deferPtr, align 4
+  %callback.gep = getelementptr inbounds %runtime._defer, %runtime._defer* %5, i32 0, i32 0
+  %callback = load i32, i32* %callback.gep, align 4
+  switch i32 %callback, label %rundefers.default [
+    i32 0, label %rundefers.callback0
+    i32 1, label %rundefers.callback1
+  ]
+
+rundefers.callback0:                              ; preds = %rundefers.loop
+  %setjmp4 = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(%runtime.deferFrame* nonnull %deferframe.buf) #4
+  %setjmp.result5 = icmp eq i32 %setjmp4, 0
+  br i1 %setjmp.result5, label %6, label %lpad
+
+6:                                                ; preds = %rundefers.callback0
+  call void @"main.deferMultiple$1"(i8* undef)
+  br label %rundefers.loophead
+
+rundefers.callback1:                              ; preds = %rundefers.loop
+  %setjmp7 = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(%runtime.deferFrame* nonnull %deferframe.buf) #4
+  %setjmp.result8 = icmp eq i32 %setjmp7, 0
+  br i1 %setjmp.result8, label %7, label %lpad
+
+7:                                                ; preds = %rundefers.callback1
+  call void @"main.deferMultiple$2"(i8* undef)
+  br label %rundefers.loophead
+
+rundefers.default:                                ; preds = %rundefers.loop
+  unreachable
+
+rundefers.end:                                    ; preds = %rundefers.loophead
+  call void @runtime.destroyDeferFrame(%runtime.deferFrame* nonnull %deferframe.buf, i8* undef) #3
+  ret void
+
+recover:                                          ; preds = %rundefers.end9
+  call void @runtime.destroyDeferFrame(%runtime.deferFrame* nonnull %deferframe.buf, i8* undef) #3
+  ret void
+
+lpad:                                             ; preds = %rundefers.callback122, %rundefers.callback018, %rundefers.callback1, %rundefers.callback0, %entry
+  br label %rundefers.loophead12
+
+rundefers.loophead12:                             ; preds = %10, %9, %lpad
+  %8 = load %runtime._defer*, %runtime._defer** %deferPtr, align 4
+  %stackIsNil13 = icmp eq %runtime._defer* %8, null
+  br i1 %stackIsNil13, label %rundefers.end9, label %rundefers.loop11
+
+rundefers.loop11:                                 ; preds = %rundefers.loophead12
+  %stack.next.gep14 = getelementptr inbounds %runtime._defer, %runtime._defer* %8, i32 0, i32 1
+  %stack.next15 = load %runtime._defer*, %runtime._defer** %stack.next.gep14, align 4
+  store %runtime._defer* %stack.next15, %runtime._defer** %deferPtr, align 4
+  %callback.gep16 = getelementptr inbounds %runtime._defer, %runtime._defer* %8, i32 0, i32 0
+  %callback17 = load i32, i32* %callback.gep16, align 4
+  switch i32 %callback17, label %rundefers.default10 [
+    i32 0, label %rundefers.callback018
+    i32 1, label %rundefers.callback122
+  ]
+
+rundefers.callback018:                            ; preds = %rundefers.loop11
+  %setjmp20 = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(%runtime.deferFrame* nonnull %deferframe.buf) #4
+  %setjmp.result21 = icmp eq i32 %setjmp20, 0
+  br i1 %setjmp.result21, label %9, label %lpad
+
+9:                                                ; preds = %rundefers.callback018
+  call void @"main.deferMultiple$1"(i8* undef)
+  br label %rundefers.loophead12
+
+rundefers.callback122:                            ; preds = %rundefers.loop11
+  %setjmp24 = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(%runtime.deferFrame* nonnull %deferframe.buf) #4
+  %setjmp.result25 = icmp eq i32 %setjmp24, 0
+  br i1 %setjmp.result25, label %10, label %lpad
+
+10:                                               ; preds = %rundefers.callback122
+  call void @"main.deferMultiple$2"(i8* undef)
+  br label %rundefers.loophead12
+
+rundefers.default10:                              ; preds = %rundefers.loop11
+  unreachable
+
+rundefers.end9:                                   ; preds = %rundefers.loophead12
+  br label %recover
+}
+
+; Function Attrs: nounwind
+define internal void @"main.deferMultiple$1"(i8* %context) unnamed_addr #1 {
+entry:
+  call void @runtime.printint32(i32 3, i8* undef) #3
+  ret void
+}
+
+; Function Attrs: nounwind
+define internal void @"main.deferMultiple$2"(i8* %context) unnamed_addr #1 {
+entry:
+  call void @runtime.printint32(i32 5, i8* undef) #3
+  ret void
+}
+
+attributes #0 = { "target-features"="+armv7-m,+hwdiv,+soft-float,+strict-align,+thumb-mode,-aes,-bf16,-cdecp0,-cdecp1,-cdecp2,-cdecp3,-cdecp4,-cdecp5,-cdecp6,-cdecp7,-crc,-crypto,-d32,-dotprod,-dsp,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fp64,-fpregs,-fullfp16,-hwdiv-arm,-i8mm,-lob,-mve,-mve.fp,-neon,-pacbti,-ras,-sb,-sha2,-vfp2,-vfp2sp,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp" }
+attributes #1 = { nounwind "target-features"="+armv7-m,+hwdiv,+soft-float,+strict-align,+thumb-mode,-aes,-bf16,-cdecp0,-cdecp1,-cdecp2,-cdecp3,-cdecp4,-cdecp5,-cdecp6,-cdecp7,-crc,-crypto,-d32,-dotprod,-dsp,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fp64,-fpregs,-fullfp16,-hwdiv-arm,-i8mm,-lob,-mve,-mve.fp,-neon,-pacbti,-ras,-sb,-sha2,-vfp2,-vfp2sp,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp" }
+attributes #2 = { nofree nosync nounwind willreturn }
+attributes #3 = { nounwind }
+attributes #4 = { nounwind returns_twice }
@@ -0,0 +1,20 @@
+package main
+
+func external()
+
+func deferSimple() {
+	defer func() {
+		print(3)
+	}()
+	external()
+}
+
+func deferMultiple() {
+	defer func() {
+		print(3)
+	}()
+	defer func() {
+		print(5)
+	}()
+	external()
+}
@@ -1,20 +1,20 @@
 ; 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-p10:8:8-p20:8:8-i64:64-n32:64-S128-ni:1:10:20"
 target triple = "wasm32-unknown-wasi"

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

-declare void @runtime.trackPointer(i8* nocapture readonly, i8*)
+declare void @runtime.trackPointer(i8* nocapture readonly, i8*) #0

 ; Function Attrs: nounwind
-define hidden void @main.init(i8* %context) unnamed_addr #0 {
+define hidden void @main.init(i8* %context) unnamed_addr #1 {
 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) unnamed_addr #1 {
 entry:
  %positive = fcmp oge float %v, 0.000000e+00
  %withinmax = fcmp ole float %v, 0x41EFFFFFC0000000
@@ -26,25 +26,25 @@ entry:
 }

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

 ; Function Attrs: nounwind
-define hidden i32 @main.maxu32tof32(i8* %context) unnamed_addr #0 {
+define hidden i32 @main.maxu32tof32(i8* %context) unnamed_addr #1 {
 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) unnamed_addr #1 {
 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) unnamed_addr #1 {
 entry:
  %0 = uitofp i32 %v to float
  %withinmax = fcmp ole float %0, 0x41EFFFFFC0000000
@@ -54,7 +54,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) unnamed_addr #1 {
 entry:
  %positive = fcmp oge float %v, 0.000000e+00
  %withinmax = fcmp ole float %v, 0x41EFFFFFC0000000
@@ -67,7 +67,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) unnamed_addr #1 {
 entry:
  %positive = fcmp oge float %v, 0.000000e+00
  %withinmax = fcmp ole float %v, 2.550000e+02
@@ -79,7 +79,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) unnamed_addr #1 {
 entry:
  %abovemin = fcmp oge float %v, -1.280000e+02
  %belowmax = fcmp ole float %v, 1.270000e+02
@@ -92,4 +92,5 @@ entry:
  ret i8 %0
 }

-attributes #0 = { nounwind }
+attributes #0 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #1 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
@@ -1,47 +1,49 @@
 ; 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 datalayout = "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-n32:64-S128-ni:1:10:20"
 target triple = "wasm32-unknown-wasi"

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

-declare void @runtime.trackPointer(i8* nocapture readonly, i8*)
+declare void @runtime.trackPointer(i8* nocapture readonly, i8*) #0

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

 ; Function Attrs: nounwind
-define hidden void @main.foo(i8* %callback.context, void ()* %callback.funcptr, i8* %context) unnamed_addr #0 {
+define hidden void @main.foo(i8* %callback.context, void ()* %callback.funcptr, i8* %context) unnamed_addr #1 {
 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
+  call void %1(i32 3, i8* %callback.context) #2
  ret void
+
+fpcall.throw:                                     ; preds = %entry
+  call void @runtime.nilPanic(i8* undef) #2
+  unreachable
 }

-declare void @runtime.nilPanic(i8*)
+declare void @runtime.nilPanic(i8*) #0

 ; Function Attrs: nounwind
-define hidden void @main.bar(i8* %context) unnamed_addr #0 {
+define hidden void @main.bar(i8* %context) unnamed_addr #1 {
 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 {
+define hidden void @main.someFunc(i32 %arg0, i8* %context) unnamed_addr #1 {
 entry:
  ret void
 }

-attributes #0 = { nounwind }
+attributes #0 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #1 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #2 = { nounwind }
@@ -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-p10:8:8-p20:8:8-i64:64-n32:64-S128-ni:1:10:20"
 target triple = "wasm32-unknown-wasi"

 %runtime.typecodeID = type { %runtime.typecodeID*, i32, %runtime.interfaceMethodInfo*, %runtime.typecodeID*, i32 }
@@ -26,91 +26,91 @@ target triple = "wasm32-unknown-wasi"
@"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 noalias nonnull i8* @runtime.alloc(i32, i8*, i8*) #0

-declare void @runtime.trackPointer(i8* nocapture readonly, i8*)
+declare void @runtime.trackPointer(i8* nocapture readonly, i8*) #0

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

 ; Function Attrs: nounwind
-define hidden void @main.newScalar(i8* %context) unnamed_addr #0 {
+define hidden void @main.newScalar(i8* %context) unnamed_addr #1 {
 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) #2
+  call void @runtime.trackPointer(i8* nonnull %new, i8* undef) #2
  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) #2
+  call void @runtime.trackPointer(i8* nonnull %new1, i8* undef) #2
  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) #2
+  call void @runtime.trackPointer(i8* nonnull %new2, i8* undef) #2
  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) #2
+  call void @runtime.trackPointer(i8* nonnull %new3, i8* undef) #2
  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) unnamed_addr #1 {
 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) #2
+  call void @runtime.trackPointer(i8* nonnull %new, i8* undef) #2
  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) #2
+  call void @runtime.trackPointer(i8* nonnull %new1, i8* undef) #2
  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) #2
+  call void @runtime.trackPointer(i8* nonnull %new2, i8* undef) #2
  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) unnamed_addr #1 {
 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) #2
+  call void @runtime.trackPointer(i8* nonnull %new, i8* undef) #2
  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) #2
+  call void @runtime.trackPointer(i8* nonnull %new1, i8* undef) #2
  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) #2
+  call void @runtime.trackPointer(i8* nonnull %new2, i8* undef) #2
  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
+  %new3 = call i8* @runtime.alloc(i32 248, i8* bitcast ({ i32, [8 x i8] }* @"runtime/gc.layout:62-0001" to i8*), i8* undef) #2
+  call void @runtime.trackPointer(i8* nonnull %new3, i8* undef) #2
  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) unnamed_addr #1 {
 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) #2
  %0 = bitcast i8* %new to { i8*, void ()* }*
-  call void @runtime.trackPointer(i8* nonnull %new, i8* undef) #0
+  call void @runtime.trackPointer(i8* nonnull %new, i8* undef) #2
  ret { i8*, void ()* }* %0
 }

 ; Function Attrs: nounwind
-define hidden void @main.makeSlice(i8* %context) unnamed_addr #0 {
+define hidden void @main.makeSlice(i8* %context) unnamed_addr #1 {
 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) #2
+  call void @runtime.trackPointer(i8* nonnull %makeslice, i8* undef) #2
  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) #2
+  call void @runtime.trackPointer(i8* nonnull %makeslice1, i8* undef) #2
  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) #2
+  call void @runtime.trackPointer(i8* nonnull %makeslice3, i8* undef) #2
  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,18 +118,20 @@ 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) unnamed_addr #1 {
 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) #2
+  call void @runtime.trackPointer(i8* nonnull %0, i8* undef) #2
  %.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
+  call void @runtime.trackPointer(i8* nonnull %0, i8* undef) #2
  ret %runtime._interface %2
 }

-attributes #0 = { nounwind }
+attributes #0 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #1 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #2 = { nounwind }
@@ -0,0 +1,30 @@
+package main
+
+import "unsafe"
+
+type Coord interface {
+	int | float32
+}
+
+type Point[T Coord] struct {
+	X, Y T
+}
+
+func Add[T Coord](a, b Point[T]) Point[T] {
+	checkSize(unsafe.Alignof(a))
+	checkSize(unsafe.Sizeof(a))
+	return Point[T]{
+		X: a.X + b.X,
+		Y: a.Y + b.Y,
+	}
+}
+
+func main() {
+	var af, bf Point[float32]
+	Add(af, bf)
+
+	var ai, bi Point[int]
+	Add(ai, bi)
+}
+
+func checkSize(uintptr)
@@ -0,0 +1,259 @@
+; ModuleID = 'generics.go'
+source_filename = "generics.go"
+target datalayout = "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-n32:64-S128-ni:1:10:20"
+target triple = "wasm32-unknown-wasi"
+
+%"main.Point[int]" = type { i32, i32 }
+%"main.Point[float32]" = type { float, float }
+
+declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*) #0
+
+declare void @runtime.trackPointer(i8* nocapture readonly, i8*) #0
+
+; Function Attrs: nounwind
+define hidden void @main.init(i8* %context) unnamed_addr #1 {
+entry:
+  ret void
+}
+
+; Function Attrs: nounwind
+define hidden void @main.main(i8* %context) unnamed_addr #1 {
+entry:
+  %bi = alloca %"main.Point[int]", align 8
+  %ai = alloca %"main.Point[int]", align 8
+  %bf = alloca %"main.Point[float32]", align 8
+  %af = alloca %"main.Point[float32]", align 8
+  %af.repack = getelementptr inbounds %"main.Point[float32]", %"main.Point[float32]"* %af, i32 0, i32 0
+  store float 0.000000e+00, float* %af.repack, align 8
+  %af.repack1 = getelementptr inbounds %"main.Point[float32]", %"main.Point[float32]"* %af, i32 0, i32 1
+  store float 0.000000e+00, float* %af.repack1, align 4
+  %0 = bitcast %"main.Point[float32]"* %af to i8*
+  call void @runtime.trackPointer(i8* nonnull %0, i8* undef) #2
+  %bf.repack = getelementptr inbounds %"main.Point[float32]", %"main.Point[float32]"* %bf, i32 0, i32 0
+  store float 0.000000e+00, float* %bf.repack, align 8
+  %bf.repack2 = getelementptr inbounds %"main.Point[float32]", %"main.Point[float32]"* %bf, i32 0, i32 1
+  store float 0.000000e+00, float* %bf.repack2, align 4
+  %1 = bitcast %"main.Point[float32]"* %bf to i8*
+  call void @runtime.trackPointer(i8* nonnull %1, i8* undef) #2
+  %.elt = getelementptr inbounds %"main.Point[float32]", %"main.Point[float32]"* %af, i32 0, i32 0
+  %.unpack = load float, float* %.elt, align 8
+  %.elt3 = getelementptr inbounds %"main.Point[float32]", %"main.Point[float32]"* %af, i32 0, i32 1
+  %.unpack4 = load float, float* %.elt3, align 4
+  %.elt5 = getelementptr inbounds %"main.Point[float32]", %"main.Point[float32]"* %bf, i32 0, i32 0
+  %.unpack6 = load float, float* %.elt5, align 8
+  %.elt7 = getelementptr inbounds %"main.Point[float32]", %"main.Point[float32]"* %bf, i32 0, i32 1
+  %.unpack8 = load float, float* %.elt7, align 4
+  %2 = call %"main.Point[float32]" @"main.Add[float32]"(float %.unpack, float %.unpack4, float %.unpack6, float %.unpack8, i8* undef)
+  %ai.repack = getelementptr inbounds %"main.Point[int]", %"main.Point[int]"* %ai, i32 0, i32 0
+  store i32 0, i32* %ai.repack, align 8
+  %ai.repack9 = getelementptr inbounds %"main.Point[int]", %"main.Point[int]"* %ai, i32 0, i32 1
+  store i32 0, i32* %ai.repack9, align 4
+  %3 = bitcast %"main.Point[int]"* %ai to i8*
+  call void @runtime.trackPointer(i8* nonnull %3, i8* undef) #2
+  %bi.repack = getelementptr inbounds %"main.Point[int]", %"main.Point[int]"* %bi, i32 0, i32 0
+  store i32 0, i32* %bi.repack, align 8
+  %bi.repack10 = getelementptr inbounds %"main.Point[int]", %"main.Point[int]"* %bi, i32 0, i32 1
+  store i32 0, i32* %bi.repack10, align 4
+  %4 = bitcast %"main.Point[int]"* %bi to i8*
+  call void @runtime.trackPointer(i8* nonnull %4, i8* undef) #2
+  %.elt11 = getelementptr inbounds %"main.Point[int]", %"main.Point[int]"* %ai, i32 0, i32 0
+  %.unpack12 = load i32, i32* %.elt11, align 8
+  %.elt13 = getelementptr inbounds %"main.Point[int]", %"main.Point[int]"* %ai, i32 0, i32 1
+  %.unpack14 = load i32, i32* %.elt13, align 4
+  %.elt15 = getelementptr inbounds %"main.Point[int]", %"main.Point[int]"* %bi, i32 0, i32 0
+  %.unpack16 = load i32, i32* %.elt15, align 8
+  %.elt17 = getelementptr inbounds %"main.Point[int]", %"main.Point[int]"* %bi, i32 0, i32 1
+  %.unpack18 = load i32, i32* %.elt17, align 4
+  %5 = call %"main.Point[int]" @"main.Add[int]"(i32 %.unpack12, i32 %.unpack14, i32 %.unpack16, i32 %.unpack18, i8* undef)
+  ret void
+}
+
+; Function Attrs: nounwind
+define linkonce_odr hidden %"main.Point[float32]" @"main.Add[float32]"(float %a.X, float %a.Y, float %b.X, float %b.Y, i8* %context) unnamed_addr #1 {
+entry:
+  %complit = alloca %"main.Point[float32]", align 8
+  %b = alloca %"main.Point[float32]", align 8
+  %a = alloca %"main.Point[float32]", align 8
+  %a.repack = getelementptr inbounds %"main.Point[float32]", %"main.Point[float32]"* %a, i32 0, i32 0
+  store float 0.000000e+00, float* %a.repack, align 8
+  %a.repack9 = getelementptr inbounds %"main.Point[float32]", %"main.Point[float32]"* %a, i32 0, i32 1
+  store float 0.000000e+00, float* %a.repack9, align 4
+  %0 = bitcast %"main.Point[float32]"* %a to i8*
+  call void @runtime.trackPointer(i8* nonnull %0, i8* undef) #2
+  %a.repack10 = getelementptr inbounds %"main.Point[float32]", %"main.Point[float32]"* %a, i32 0, i32 0
+  store float %a.X, float* %a.repack10, align 8
+  %a.repack11 = getelementptr inbounds %"main.Point[float32]", %"main.Point[float32]"* %a, i32 0, i32 1
+  store float %a.Y, float* %a.repack11, align 4
+  %b.repack = getelementptr inbounds %"main.Point[float32]", %"main.Point[float32]"* %b, i32 0, i32 0
+  store float 0.000000e+00, float* %b.repack, align 8
+  %b.repack13 = getelementptr inbounds %"main.Point[float32]", %"main.Point[float32]"* %b, i32 0, i32 1
+  store float 0.000000e+00, float* %b.repack13, align 4
+  %1 = bitcast %"main.Point[float32]"* %b to i8*
+  call void @runtime.trackPointer(i8* nonnull %1, i8* undef) #2
+  %b.repack14 = getelementptr inbounds %"main.Point[float32]", %"main.Point[float32]"* %b, i32 0, i32 0
+  store float %b.X, float* %b.repack14, align 8
+  %b.repack15 = getelementptr inbounds %"main.Point[float32]", %"main.Point[float32]"* %b, i32 0, i32 1
+  store float %b.Y, float* %b.repack15, align 4
+  call void @main.checkSize(i32 4, i8* undef) #2
+  call void @main.checkSize(i32 8, i8* undef) #2
+  %complit.repack = getelementptr inbounds %"main.Point[float32]", %"main.Point[float32]"* %complit, i32 0, i32 0
+  store float 0.000000e+00, float* %complit.repack, align 8
+  %complit.repack17 = getelementptr inbounds %"main.Point[float32]", %"main.Point[float32]"* %complit, i32 0, i32 1
+  store float 0.000000e+00, float* %complit.repack17, align 4
+  %2 = bitcast %"main.Point[float32]"* %complit to i8*
+  call void @runtime.trackPointer(i8* nonnull %2, i8* undef) #2
+  %3 = getelementptr inbounds %"main.Point[float32]", %"main.Point[float32]"* %complit, i32 0, i32 0
+  br i1 false, label %deref.throw, label %deref.next
+
+deref.next:                                       ; preds = %entry
+  br i1 false, label %deref.throw1, label %deref.next2
+
+deref.next2:                                      ; preds = %deref.next
+  %4 = getelementptr inbounds %"main.Point[float32]", %"main.Point[float32]"* %b, i32 0, i32 0
+  %5 = getelementptr inbounds %"main.Point[float32]", %"main.Point[float32]"* %a, i32 0, i32 0
+  %6 = load float, float* %5, align 8
+  %7 = load float, float* %4, align 8
+  %8 = fadd float %6, %7
+  br i1 false, label %deref.throw3, label %deref.next4
+
+deref.next4:                                      ; preds = %deref.next2
+  br i1 false, label %deref.throw5, label %deref.next6
+
+deref.next6:                                      ; preds = %deref.next4
+  %9 = getelementptr inbounds %"main.Point[float32]", %"main.Point[float32]"* %b, i32 0, i32 1
+  %10 = getelementptr inbounds %"main.Point[float32]", %"main.Point[float32]"* %a, i32 0, i32 1
+  %11 = load float, float* %10, align 4
+  %12 = load float, float* %9, align 4
+  br i1 false, label %store.throw, label %store.next
+
+store.next:                                       ; preds = %deref.next6
+  store float %8, float* %3, align 8
+  br i1 false, label %store.throw7, label %store.next8
+
+store.next8:                                      ; preds = %store.next
+  %13 = getelementptr inbounds %"main.Point[float32]", %"main.Point[float32]"* %complit, i32 0, i32 1
+  %14 = fadd float %11, %12
+  store float %14, float* %13, align 4
+  %.elt = getelementptr inbounds %"main.Point[float32]", %"main.Point[float32]"* %complit, i32 0, i32 0
+  %.unpack = load float, float* %.elt, align 8
+  %15 = insertvalue %"main.Point[float32]" undef, float %.unpack, 0
+  %16 = insertvalue %"main.Point[float32]" %15, float %14, 1
+  ret %"main.Point[float32]" %16
+
+deref.throw:                                      ; preds = %entry
+  unreachable
+
+deref.throw1:                                     ; preds = %deref.next
+  unreachable
+
+deref.throw3:                                     ; preds = %deref.next2
+  unreachable
+
+deref.throw5:                                     ; preds = %deref.next4
+  unreachable
+
+store.throw:                                      ; preds = %deref.next6
+  unreachable
+
+store.throw7:                                     ; preds = %store.next
+  unreachable
+}
+
+declare void @main.checkSize(i32, i8*) #0
+
+declare void @runtime.nilPanic(i8*) #0
+
+; Function Attrs: nounwind
+define linkonce_odr hidden %"main.Point[int]" @"main.Add[int]"(i32 %a.X, i32 %a.Y, i32 %b.X, i32 %b.Y, i8* %context) unnamed_addr #1 {
+entry:
+  %complit = alloca %"main.Point[int]", align 8
+  %b = alloca %"main.Point[int]", align 8
+  %a = alloca %"main.Point[int]", align 8
+  %a.repack = getelementptr inbounds %"main.Point[int]", %"main.Point[int]"* %a, i32 0, i32 0
+  store i32 0, i32* %a.repack, align 8
+  %a.repack9 = getelementptr inbounds %"main.Point[int]", %"main.Point[int]"* %a, i32 0, i32 1
+  store i32 0, i32* %a.repack9, align 4
+  %0 = bitcast %"main.Point[int]"* %a to i8*
+  call void @runtime.trackPointer(i8* nonnull %0, i8* undef) #2
+  %a.repack10 = getelementptr inbounds %"main.Point[int]", %"main.Point[int]"* %a, i32 0, i32 0
+  store i32 %a.X, i32* %a.repack10, align 8
+  %a.repack11 = getelementptr inbounds %"main.Point[int]", %"main.Point[int]"* %a, i32 0, i32 1
+  store i32 %a.Y, i32* %a.repack11, align 4
+  %b.repack = getelementptr inbounds %"main.Point[int]", %"main.Point[int]"* %b, i32 0, i32 0
+  store i32 0, i32* %b.repack, align 8
+  %b.repack13 = getelementptr inbounds %"main.Point[int]", %"main.Point[int]"* %b, i32 0, i32 1
+  store i32 0, i32* %b.repack13, align 4
+  %1 = bitcast %"main.Point[int]"* %b to i8*
+  call void @runtime.trackPointer(i8* nonnull %1, i8* undef) #2
+  %b.repack14 = getelementptr inbounds %"main.Point[int]", %"main.Point[int]"* %b, i32 0, i32 0
+  store i32 %b.X, i32* %b.repack14, align 8
+  %b.repack15 = getelementptr inbounds %"main.Point[int]", %"main.Point[int]"* %b, i32 0, i32 1
+  store i32 %b.Y, i32* %b.repack15, align 4
+  call void @main.checkSize(i32 4, i8* undef) #2
+  call void @main.checkSize(i32 8, i8* undef) #2
+  %complit.repack = getelementptr inbounds %"main.Point[int]", %"main.Point[int]"* %complit, i32 0, i32 0
+  store i32 0, i32* %complit.repack, align 8
+  %complit.repack17 = getelementptr inbounds %"main.Point[int]", %"main.Point[int]"* %complit, i32 0, i32 1
+  store i32 0, i32* %complit.repack17, align 4
+  %2 = bitcast %"main.Point[int]"* %complit to i8*
+  call void @runtime.trackPointer(i8* nonnull %2, i8* undef) #2
+  %3 = getelementptr inbounds %"main.Point[int]", %"main.Point[int]"* %complit, i32 0, i32 0
+  br i1 false, label %deref.throw, label %deref.next
+
+deref.next:                                       ; preds = %entry
+  br i1 false, label %deref.throw1, label %deref.next2
+
+deref.next2:                                      ; preds = %deref.next
+  %4 = getelementptr inbounds %"main.Point[int]", %"main.Point[int]"* %b, i32 0, i32 0
+  %5 = getelementptr inbounds %"main.Point[int]", %"main.Point[int]"* %a, i32 0, i32 0
+  %6 = load i32, i32* %5, align 8
+  %7 = load i32, i32* %4, align 8
+  %8 = add i32 %6, %7
+  br i1 false, label %deref.throw3, label %deref.next4
+
+deref.next4:                                      ; preds = %deref.next2
+  br i1 false, label %deref.throw5, label %deref.next6
+
+deref.next6:                                      ; preds = %deref.next4
+  %9 = getelementptr inbounds %"main.Point[int]", %"main.Point[int]"* %b, i32 0, i32 1
+  %10 = getelementptr inbounds %"main.Point[int]", %"main.Point[int]"* %a, i32 0, i32 1
+  %11 = load i32, i32* %10, align 4
+  %12 = load i32, i32* %9, align 4
+  br i1 false, label %store.throw, label %store.next
+
+store.next:                                       ; preds = %deref.next6
+  store i32 %8, i32* %3, align 8
+  br i1 false, label %store.throw7, label %store.next8
+
+store.next8:                                      ; preds = %store.next
+  %13 = getelementptr inbounds %"main.Point[int]", %"main.Point[int]"* %complit, i32 0, i32 1
+  %14 = add i32 %11, %12
+  store i32 %14, i32* %13, align 4
+  %.elt = getelementptr inbounds %"main.Point[int]", %"main.Point[int]"* %complit, i32 0, i32 0
+  %.unpack = load i32, i32* %.elt, align 8
+  %15 = insertvalue %"main.Point[int]" undef, i32 %.unpack, 0
+  %16 = insertvalue %"main.Point[int]" %15, i32 %14, 1
+  ret %"main.Point[int]" %16
+
+deref.throw:                                      ; preds = %entry
+  unreachable
+
+deref.throw1:                                     ; preds = %deref.next
+  unreachable
+
+deref.throw3:                                     ; preds = %deref.next2
+  unreachable
+
+deref.throw5:                                     ; preds = %deref.next4
+  unreachable
+
+store.throw:                                      ; preds = %deref.next6
+  unreachable
+
+store.throw7:                                     ; preds = %store.next
+  unreachable
+}
+
+attributes #0 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #1 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #2 = { nounwind }
@@ -1,41 +0,0 @@
-package main
-
-// Test changes to the language introduced in Go 1.17.
-// For details, see: https://tip.golang.org/doc/go1.17#language
-// These tests should be merged into the regular slice tests once Go 1.17 is the
-// minimun Go version for TinyGo.
-
-import "unsafe"
-
-func Add32(p unsafe.Pointer, len int) unsafe.Pointer {
-	return unsafe.Add(p, len)
-}
-
-func Add64(p unsafe.Pointer, len int64) unsafe.Pointer {
-	return unsafe.Add(p, len)
-}
-
-func SliceToArray(s []int) *[4]int {
-	return (*[4]int)(s)
-}
-
-func SliceToArrayConst() *[4]int {
-	s := make([]int, 6)
-	return (*[4]int)(s)
-}
-
-func SliceInt(ptr *int, len int) []int {
-	return unsafe.Slice(ptr, len)
-}
-
-func SliceUint16(ptr *byte, len uint16) []byte {
-	return unsafe.Slice(ptr, len)
-}
-
-func SliceUint64(ptr *int, len uint64) []int {
-	return unsafe.Slice(ptr, len)
-}
-
-func SliceInt64(ptr *int, len int64) []int {
-	return unsafe.Slice(ptr, len)
-}
@@ -1,159 +0,0 @@
-; 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 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 i8* @main.Add32(i8* %p, i32 %len, i8* %context) 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 {
-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 {
-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
-  unreachable
-
-slicetoarray.next:                                ; preds = %entry
-  %1 = bitcast i32* %s.data to [4 x i32]*
-  ret [4 x i32]* %1
-}
-
-declare void @runtime.sliceToArrayPointerPanic(i8*)
-
-; Function Attrs: nounwind
-define hidden [4 x i32]* @main.SliceToArrayConst(i8* %context) 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
-  br i1 false, label %slicetoarray.throw, label %slicetoarray.next
-
-slicetoarray.throw:                               ; preds = %entry
-  unreachable
-
-slicetoarray.next:                                ; preds = %entry
-  %0 = bitcast i8* %makeslice to [4 x i32]*
-  ret [4 x i32]* %0
-}
-
-; Function Attrs: nounwind
-define hidden { i32*, i32, i32 } @main.SliceInt(i32* dereferenceable_or_null(4) %ptr, i32 %len, i8* %context) unnamed_addr #0 {
-entry:
-  %0 = icmp ugt i32 %len, 1073741823
-  %1 = icmp eq i32* %ptr, null
-  %2 = icmp ne i32 %len, 0
-  %3 = and i1 %1, %2
-  %4 = or i1 %3, %0
-  br i1 %4, label %unsafe.Slice.throw, label %unsafe.Slice.next
-
-unsafe.Slice.throw:                               ; preds = %entry
-  call void @runtime.unsafeSlicePanic(i8* undef) #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*)
-
-; Function Attrs: nounwind
-define hidden { i8*, i32, i32 } @main.SliceUint16(i8* dereferenceable_or_null(1) %ptr, i16 %len, i8* %context) unnamed_addr #0 {
-entry:
-  %0 = icmp eq i8* %ptr, null
-  %1 = icmp ne i16 %len, 0
-  %2 = and i1 %0, %1
-  br i1 %2, label %unsafe.Slice.throw, label %unsafe.Slice.next
-
-unsafe.Slice.throw:                               ; preds = %entry
-  call void @runtime.unsafeSlicePanic(i8* undef) #0
-  unreachable
-
-unsafe.Slice.next:                                ; preds = %entry
-  %3 = zext i16 %len to i32
-  %4 = insertvalue { i8*, i32, i32 } undef, i8* %ptr, 0
-  %5 = insertvalue { i8*, i32, i32 } %4, i32 %3, 1
-  %6 = insertvalue { i8*, i32, i32 } %5, i32 %3, 2
-  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 {
-entry:
-  %0 = icmp ugt i64 %len, 1073741823
-  %1 = icmp eq i32* %ptr, null
-  %2 = icmp ne i64 %len, 0
-  %3 = and i1 %1, %2
-  %4 = or i1 %3, %0
-  br i1 %4, label %unsafe.Slice.throw, label %unsafe.Slice.next
-
-unsafe.Slice.throw:                               ; preds = %entry
-  call void @runtime.unsafeSlicePanic(i8* undef) #0
-  unreachable
-
-unsafe.Slice.next:                                ; preds = %entry
-  %5 = trunc i64 %len to i32
-  %6 = insertvalue { i32*, i32, i32 } undef, i32* %ptr, 0
-  %7 = insertvalue { i32*, i32, i32 } %6, i32 %5, 1
-  %8 = insertvalue { i32*, i32, i32 } %7, i32 %5, 2
-  %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 {
-entry:
-  %0 = icmp ugt i64 %len, 1073741823
-  %1 = icmp eq i32* %ptr, null
-  %2 = icmp ne i64 %len, 0
-  %3 = and i1 %1, %2
-  %4 = or i1 %3, %0
-  br i1 %4, label %unsafe.Slice.throw, label %unsafe.Slice.next
-
-unsafe.Slice.throw:                               ; preds = %entry
-  call void @runtime.unsafeSlicePanic(i8* undef) #0
-  unreachable
-
-unsafe.Slice.next:                                ; preds = %entry
-  %5 = trunc i64 %len to i32
-  %6 = insertvalue { i32*, i32, i32 } undef, i32* %ptr, 0
-  %7 = insertvalue { i32*, i32, i32 } %6, i32 %5, 1
-  %8 = insertvalue { i32*, i32, i32 } %7, i32 %5, 2
-  %9 = bitcast i32* %ptr to i8*
-  call void @runtime.trackPointer(i8* %9, i8* undef) #0
-  ret { i32*, i32, i32 } %8
-}
-
-attributes #0 = { nounwind }
@@ -5,59 +5,59 @@ 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.Task" = type { %"internal/task.Task"*, i8*, i64, %"internal/task.gcData", %"internal/task.state", i8* }
 %"internal/task.gcData" = type {}
 %"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*) #0

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

 ; Function Attrs: nounwind
-define hidden void @main.regularFunctionGoroutine(i8* %context) unnamed_addr #0 {
+define hidden void @main.regularFunctionGoroutine(i8* %context) unnamed_addr #1 {
 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) #8
+  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) #8
  ret void
 }

-declare void @main.regularFunction(i32, i8*)
+declare void @main.regularFunction(i32, i8*) #0

 ; Function Attrs: nounwind
-define linkonce_odr void @"main.regularFunction$gowrapper"(i8* %0) unnamed_addr #1 {
+define linkonce_odr void @"main.regularFunction$gowrapper"(i8* %0) unnamed_addr #2 {
 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) #8
  ret void
 }

-declare i32 @"internal/task.getGoroutineStackSize"(i32, i8*)
+declare i32 @"internal/task.getGoroutineStackSize"(i32, i8*) #0

-declare void @"internal/task.start"(i32, i8*, i32, i8*)
+declare void @"internal/task.start"(i32, i8*, i32, i8*) #0

 ; Function Attrs: nounwind
-define hidden void @main.inlineFunctionGoroutine(i8* %context) unnamed_addr #0 {
+define hidden void @main.inlineFunctionGoroutine(i8* %context) unnamed_addr #1 {
 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) #8
+  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) #8
  ret void
 }

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

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

 ; Function Attrs: nounwind
-define hidden void @main.closureFunctionGoroutine(i8* %context) unnamed_addr #0 {
+define hidden void @main.closureFunctionGoroutine(i8* %context) unnamed_addr #1 {
 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) #8
  %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) #8
  %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) #8
+  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"main.closureFunctionGoroutine$1$gowrapper" to i32), i8* nonnull %1, i32 %stacksize, i8* undef) #8
  %5 = load i32, i32* %0, align 4
-  call void @runtime.printint32(i32 %5, i8* undef) #0
+  call void @runtime.printint32(i32 %5, i8* undef) #8
  ret void
 }

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

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

-declare void @runtime.printint32(i32, i8*)
+declare void @runtime.printint32(i32, i8*) #0

 ; 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) unnamed_addr #1 {
 entry:
-  %0 = call i8* @runtime.alloc(i32 12, i8* null, i8* undef) #0
+  %0 = call i8* @runtime.alloc(i32 12, i8* null, i8* undef) #8
  %1 = bitcast i8* %0 to i32*
  store i32 5, i32* %1, align 4
  %2 = getelementptr inbounds i8, i8* %0, i32 4
@@ -117,13 +117,13 @@ 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) #8
+  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @main.funcGoroutine.gowrapper to i32), i8* nonnull %0, i32 %stacksize, i8* undef) #8
  ret void
 }

 ; Function Attrs: nounwind
-define linkonce_odr void @main.funcGoroutine.gowrapper(i8* %0) unnamed_addr #4 {
+define linkonce_odr void @main.funcGoroutine.gowrapper(i8* %0) unnamed_addr #5 {
 entry:
  %1 = bitcast i8* %0 to i32*
  %2 = load i32, i32* %1, align 4
@@ -133,38 +133,38 @@ entry:
  %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 %8(i32 %2, i8* %5) #8
  ret void
 }

 ; Function Attrs: nounwind
-define hidden void @main.recoverBuiltinGoroutine(i8* %context) unnamed_addr #0 {
+define hidden void @main.recoverBuiltinGoroutine(i8* %context) unnamed_addr #1 {
 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) unnamed_addr #1 {
 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) #8
  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*) #0

 ; 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) unnamed_addr #1 {
 entry:
-  call void @runtime.chanClose(%runtime.channel* %ch, i8* undef) #0
+  call void @runtime.chanClose(%runtime.channel* %ch, i8* undef) #8
  ret void
 }

-declare void @runtime.chanClose(%runtime.channel* dereferenceable_or_null(32), i8*)
+declare void @runtime.chanClose(%runtime.channel* dereferenceable_or_null(32), i8*) #0

 ; 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) unnamed_addr #1 {
 entry:
-  %0 = call i8* @runtime.alloc(i32 16, i8* null, i8* undef) #0
+  %0 = call i8* @runtime.alloc(i32 16, i8* null, i8* undef) #8
  %1 = bitcast i8* %0 to i8**
  store i8* %itf.value, i8** %1, align 4
  %2 = getelementptr inbounds i8, i8* %0, i32 4
@@ -176,15 +176,15 @@ 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) #8
+  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) #8
  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*) #6

 ; Function Attrs: nounwind
-define linkonce_odr void @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper"(i8* %0) unnamed_addr #6 {
+define linkonce_odr void @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper"(i8* %0) unnamed_addr #7 {
 entry:
  %1 = bitcast i8* %0 to i8**
  %2 = load i8*, i8** %1, align 4
@@ -197,14 +197,16 @@ 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) #8
  ret void
 }

-attributes #0 = { nounwind }
-attributes #1 = { nounwind "tinygo-gowrapper"="main.regularFunction" }
-attributes #2 = { nounwind "tinygo-gowrapper"="main.inlineFunctionGoroutine$1" }
-attributes #3 = { nounwind "tinygo-gowrapper"="main.closureFunctionGoroutine$1" }
-attributes #4 = { nounwind "tinygo-gowrapper" }
-attributes #5 = { "tinygo-invoke"="reflect/methods.Print(string)" "tinygo-methods"="reflect/methods.Print(string)" }
-attributes #6 = { nounwind "tinygo-gowrapper"="interface:{Print:func:{basic:string}{}}.Print$invoke" }
+attributes #0 = { "target-features"="+armv7-m,+hwdiv,+soft-float,+strict-align,+thumb-mode,-aes,-bf16,-cdecp0,-cdecp1,-cdecp2,-cdecp3,-cdecp4,-cdecp5,-cdecp6,-cdecp7,-crc,-crypto,-d32,-dotprod,-dsp,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fp64,-fpregs,-fullfp16,-hwdiv-arm,-i8mm,-lob,-mve,-mve.fp,-neon,-pacbti,-ras,-sb,-sha2,-vfp2,-vfp2sp,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp" }
+attributes #1 = { nounwind "target-features"="+armv7-m,+hwdiv,+soft-float,+strict-align,+thumb-mode,-aes,-bf16,-cdecp0,-cdecp1,-cdecp2,-cdecp3,-cdecp4,-cdecp5,-cdecp6,-cdecp7,-crc,-crypto,-d32,-dotprod,-dsp,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fp64,-fpregs,-fullfp16,-hwdiv-arm,-i8mm,-lob,-mve,-mve.fp,-neon,-pacbti,-ras,-sb,-sha2,-vfp2,-vfp2sp,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp" }
+attributes #2 = { nounwind "target-features"="+armv7-m,+hwdiv,+soft-float,+strict-align,+thumb-mode,-aes,-bf16,-cdecp0,-cdecp1,-cdecp2,-cdecp3,-cdecp4,-cdecp5,-cdecp6,-cdecp7,-crc,-crypto,-d32,-dotprod,-dsp,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fp64,-fpregs,-fullfp16,-hwdiv-arm,-i8mm,-lob,-mve,-mve.fp,-neon,-pacbti,-ras,-sb,-sha2,-vfp2,-vfp2sp,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp" "tinygo-gowrapper"="main.regularFunction" }
+attributes #3 = { nounwind "target-features"="+armv7-m,+hwdiv,+soft-float,+strict-align,+thumb-mode,-aes,-bf16,-cdecp0,-cdecp1,-cdecp2,-cdecp3,-cdecp4,-cdecp5,-cdecp6,-cdecp7,-crc,-crypto,-d32,-dotprod,-dsp,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fp64,-fpregs,-fullfp16,-hwdiv-arm,-i8mm,-lob,-mve,-mve.fp,-neon,-pacbti,-ras,-sb,-sha2,-vfp2,-vfp2sp,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp" "tinygo-gowrapper"="main.inlineFunctionGoroutine$1" }
+attributes #4 = { nounwind "target-features"="+armv7-m,+hwdiv,+soft-float,+strict-align,+thumb-mode,-aes,-bf16,-cdecp0,-cdecp1,-cdecp2,-cdecp3,-cdecp4,-cdecp5,-cdecp6,-cdecp7,-crc,-crypto,-d32,-dotprod,-dsp,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fp64,-fpregs,-fullfp16,-hwdiv-arm,-i8mm,-lob,-mve,-mve.fp,-neon,-pacbti,-ras,-sb,-sha2,-vfp2,-vfp2sp,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp" "tinygo-gowrapper"="main.closureFunctionGoroutine$1" }
+attributes #5 = { nounwind "target-features"="+armv7-m,+hwdiv,+soft-float,+strict-align,+thumb-mode,-aes,-bf16,-cdecp0,-cdecp1,-cdecp2,-cdecp3,-cdecp4,-cdecp5,-cdecp6,-cdecp7,-crc,-crypto,-d32,-dotprod,-dsp,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fp64,-fpregs,-fullfp16,-hwdiv-arm,-i8mm,-lob,-mve,-mve.fp,-neon,-pacbti,-ras,-sb,-sha2,-vfp2,-vfp2sp,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp" "tinygo-gowrapper" }
+attributes #6 = { "target-features"="+armv7-m,+hwdiv,+soft-float,+strict-align,+thumb-mode,-aes,-bf16,-cdecp0,-cdecp1,-cdecp2,-cdecp3,-cdecp4,-cdecp5,-cdecp6,-cdecp7,-crc,-crypto,-d32,-dotprod,-dsp,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fp64,-fpregs,-fullfp16,-hwdiv-arm,-i8mm,-lob,-mve,-mve.fp,-neon,-pacbti,-ras,-sb,-sha2,-vfp2,-vfp2sp,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp" "tinygo-invoke"="reflect/methods.Print(string)" "tinygo-methods"="reflect/methods.Print(string)" }
+attributes #7 = { nounwind "target-features"="+armv7-m,+hwdiv,+soft-float,+strict-align,+thumb-mode,-aes,-bf16,-cdecp0,-cdecp1,-cdecp2,-cdecp3,-cdecp4,-cdecp5,-cdecp6,-cdecp7,-crc,-crypto,-d32,-dotprod,-dsp,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fp64,-fpregs,-fullfp16,-hwdiv-arm,-i8mm,-lob,-mve,-mve.fp,-neon,-pacbti,-ras,-sb,-sha2,-vfp2,-vfp2sp,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp" "tinygo-gowrapper"="interface:{Print:func:{basic:string}{}}.Print$invoke" }
+attributes #8 = { nounwind }
@@ -1,11 +1,11 @@
 ; 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-p10:8:8-p20:8:8-i64:64-n32:64-S128-ni:1:10:20"
 target triple = "wasm32-unknown-wasi"

 %runtime.channel = type { i32, i32, i8, %runtime.channelBlockedList*, i32, i32, i32, i8* }
 %runtime.channelBlockedList = type { %runtime.channelBlockedList*, %"internal/task.Task"*, %runtime.chanSelectState*, { %runtime.channelBlockedList*, i32, i32 } }
-%"internal/task.Task" = type { %"internal/task.Task"*, i8*, i64, %"internal/task.gcData", %"internal/task.state" }
+%"internal/task.Task" = type { %"internal/task.Task"*, i8*, i64, %"internal/task.gcData", %"internal/task.state", i8* }
 %"internal/task.gcData" = type { i8* }
 %"internal/task.state" = type { i32, i8*, %"internal/task.stackState", i1 }
 %"internal/task.stackState" = type { i32, i32 }
@@ -13,84 +13,84 @@ target triple = "wasm32-unknown-wasi"

@"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*) #0

-declare void @runtime.trackPointer(i8* nocapture readonly, i8*)
+declare void @runtime.trackPointer(i8* nocapture readonly, i8*) #0

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

 ; Function Attrs: nounwind
-define hidden void @main.regularFunctionGoroutine(i8* %context) unnamed_addr #0 {
+define hidden void @main.regularFunctionGoroutine(i8* %context) unnamed_addr #1 {
 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 16384, i8* undef) #8
  ret void
 }

-declare void @main.regularFunction(i32, i8*)
+declare void @main.regularFunction(i32, i8*) #0

-declare void @runtime.deadlock(i8*)
+declare void @runtime.deadlock(i8*) #0

 ; Function Attrs: nounwind
-define linkonce_odr void @"main.regularFunction$gowrapper"(i8* %0) unnamed_addr #1 {
+define linkonce_odr void @"main.regularFunction$gowrapper"(i8* %0) unnamed_addr #2 {
 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) #8
+  call void @runtime.deadlock(i8* undef) #8
  unreachable
 }

-declare void @"internal/task.start"(i32, i8*, i32, i8*)
+declare void @"internal/task.start"(i32, i8*, i32, i8*) #0

 ; Function Attrs: nounwind
-define hidden void @main.inlineFunctionGoroutine(i8* %context) unnamed_addr #0 {
+define hidden void @main.inlineFunctionGoroutine(i8* %context) unnamed_addr #1 {
 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 16384, i8* undef) #8
  ret void
 }

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

 ; Function Attrs: nounwind
-define linkonce_odr void @"main.inlineFunctionGoroutine$1$gowrapper"(i8* %0) unnamed_addr #2 {
+define linkonce_odr void @"main.inlineFunctionGoroutine$1$gowrapper"(i8* %0) unnamed_addr #3 {
 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 @runtime.deadlock(i8* undef) #8
  unreachable
 }

 ; Function Attrs: nounwind
-define hidden void @main.closureFunctionGoroutine(i8* %context) unnamed_addr #0 {
+define hidden void @main.closureFunctionGoroutine(i8* %context) unnamed_addr #1 {
 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) #8
  %0 = bitcast i8* %n to i32*
-  call void @runtime.trackPointer(i8* nonnull %n, i8* undef) #0
+  call void @runtime.trackPointer(i8* nonnull %n, i8* undef) #8
  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
+  call void @runtime.trackPointer(i8* nonnull %n, i8* undef) #8
+  call void @runtime.trackPointer(i8* bitcast (void (i32, i8*)* @"main.closureFunctionGoroutine$1" to i8*), i8* undef) #8
+  %1 = call i8* @runtime.alloc(i32 8, i8* null, i8* undef) #8
+  call void @runtime.trackPointer(i8* nonnull %1, i8* undef) #8
  %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 16384, i8* undef) #8
  %5 = load i32, i32* %0, align 4
-  call void @runtime.printint32(i32 %5, i8* undef) #0
+  call void @runtime.printint32(i32 %5, i8* undef) #8
  ret void
 }

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

 ; Function Attrs: nounwind
-define linkonce_odr void @"main.closureFunctionGoroutine$1$gowrapper"(i8* %0) unnamed_addr #3 {
+define linkonce_odr void @"main.closureFunctionGoroutine$1$gowrapper"(i8* %0) unnamed_addr #4 {
 entry:
  %1 = bitcast i8* %0 to i32*
  %2 = load i32, i32* %1, align 4
@@ -106,17 +106,17 @@ entry:
  %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 @runtime.deadlock(i8* undef) #8
  unreachable
 }

-declare void @runtime.printint32(i32, i8*)
+declare void @runtime.printint32(i32, i8*) #0

 ; 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) unnamed_addr #1 {
 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) #8
+  call void @runtime.trackPointer(i8* nonnull %0, i8* undef) #8
  %1 = bitcast i8* %0 to i32*
  store i32 5, i32* %1, align 4
  %2 = getelementptr inbounds i8, i8* %0, i32 4
@@ -125,12 +125,12 @@ 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 16384, i8* undef) #8
  ret void
 }

 ; Function Attrs: nounwind
-define linkonce_odr void @main.funcGoroutine.gowrapper(i8* %0) unnamed_addr #4 {
+define linkonce_odr void @main.funcGoroutine.gowrapper(i8* %0) unnamed_addr #5 {
 entry:
  %1 = bitcast i8* %0 to i32*
  %2 = load i32, i32* %1, align 4
@@ -140,40 +140,40 @@ entry:
  %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
+  call void %8(i32 %2, i8* %5) #8
+  call void @runtime.deadlock(i8* undef) #8
  unreachable
 }

 ; Function Attrs: nounwind
-define hidden void @main.recoverBuiltinGoroutine(i8* %context) unnamed_addr #0 {
+define hidden void @main.recoverBuiltinGoroutine(i8* %context) unnamed_addr #1 {
 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) unnamed_addr #1 {
 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) #8
  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*) #0

 ; 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) unnamed_addr #1 {
 entry:
-  call void @runtime.chanClose(%runtime.channel* %ch, i8* undef) #0
+  call void @runtime.chanClose(%runtime.channel* %ch, i8* undef) #8
  ret void
 }

-declare void @runtime.chanClose(%runtime.channel* dereferenceable_or_null(32), i8*)
+declare void @runtime.chanClose(%runtime.channel* dereferenceable_or_null(32), i8*) #0

 ; 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) unnamed_addr #1 {
 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) #8
+  call void @runtime.trackPointer(i8* nonnull %0, i8* undef) #8
  %1 = bitcast i8* %0 to i8**
  store i8* %itf.value, i8** %1, align 4
  %2 = getelementptr inbounds i8, i8* %0, i32 4
@@ -185,14 +185,14 @@ 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 16384, i8* undef) #8
  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*) #6

 ; Function Attrs: nounwind
-define linkonce_odr void @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper"(i8* %0) unnamed_addr #6 {
+define linkonce_odr void @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper"(i8* %0) unnamed_addr #7 {
 entry:
  %1 = bitcast i8* %0 to i8**
  %2 = load i8*, i8** %1, align 4
@@ -205,15 +205,17 @@ 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) #8
+  call void @runtime.deadlock(i8* undef) #8
  unreachable
 }

-attributes #0 = { nounwind }
-attributes #1 = { nounwind "tinygo-gowrapper"="main.regularFunction" }
-attributes #2 = { nounwind "tinygo-gowrapper"="main.inlineFunctionGoroutine$1" }
-attributes #3 = { nounwind "tinygo-gowrapper"="main.closureFunctionGoroutine$1" }
-attributes #4 = { nounwind "tinygo-gowrapper" }
-attributes #5 = { "tinygo-invoke"="reflect/methods.Print(string)" "tinygo-methods"="reflect/methods.Print(string)" }
-attributes #6 = { nounwind "tinygo-gowrapper"="interface:{Print:func:{basic:string}{}}.Print$invoke" }
+attributes #0 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #1 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #2 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "tinygo-gowrapper"="main.regularFunction" }
+attributes #3 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "tinygo-gowrapper"="main.inlineFunctionGoroutine$1" }
+attributes #4 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "tinygo-gowrapper"="main.closureFunctionGoroutine$1" }
+attributes #5 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "tinygo-gowrapper" }
+attributes #6 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "tinygo-invoke"="reflect/methods.Print(string)" "tinygo-methods"="reflect/methods.Print(string)" }
+attributes #7 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "tinygo-gowrapper"="interface:{Print:func:{basic:string}{}}.Print$invoke" }
+attributes #8 = { nounwind }
@@ -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-p10:8:8-p20:8:8-i64:64-n32:64-S128-ni:1:10:20"
 target triple = "wasm32-unknown-wasi"

 %runtime.typecodeID = type { %runtime.typecodeID*, i32, %runtime.interfaceMethodInfo*, %runtime.typecodeID*, i32 }
@@ -22,111 +22,113 @@ 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 noalias nonnull i8* @runtime.alloc(i32, i8*, i8*) #0

-declare void @runtime.trackPointer(i8* nocapture readonly, i8*)
+declare void @runtime.trackPointer(i8* nocapture readonly, i8*) #0

 ; Function Attrs: nounwind
-define hidden void @main.init(i8* %context) unnamed_addr #0 {
+define hidden void @main.init(i8* %context) unnamed_addr #1 {
 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) unnamed_addr #1 {
 entry:
-  call void @runtime.trackPointer(i8* null, i8* undef) #0
+  call void @runtime.trackPointer(i8* null, i8* undef) #6
  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) unnamed_addr #1 {
 entry:
-  call void @runtime.trackPointer(i8* null, i8* undef) #0
+  call void @runtime.trackPointer(i8* null, i8* undef) #6
  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) unnamed_addr #1 {
 entry:
-  call void @runtime.trackPointer(i8* null, i8* undef) #0
+  call void @runtime.trackPointer(i8* null, i8* undef) #6
  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
+declare i1 @"interface:{Error:func:{}{basic:string}}.$typeassert"(i32) #2

 ; Function Attrs: nounwind
-define hidden %runtime._interface @main.anonymousInterfaceType(i8* %context) unnamed_addr #0 {
+define hidden %runtime._interface @main.anonymousInterfaceType(i8* %context) unnamed_addr #1 {
 entry:
-  call void @runtime.trackPointer(i8* null, i8* undef) #0
+  call void @runtime.trackPointer(i8* null, i8* undef) #6
  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
+declare i1 @"interface:{String:func:{}{basic:string}}.$typeassert"(i32) #3

 ; 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) unnamed_addr #1 {
 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) #6
  br i1 %typecode, label %typeassert.ok, label %typeassert.next

-typeassert.ok:                                    ; preds = %entry
-  br label %typeassert.next
-
 typeassert.next:                                  ; preds = %typeassert.ok, %entry
  ret i1 %typecode
-}
-
-declare i1 @runtime.typeAssert(i32, i8* dereferenceable_or_null(1), i8*)
-
-; Function Attrs: nounwind
-define hidden i1 @main.isError(i32 %itf.typecode, i8* %itf.value, i8* %context) unnamed_addr #0 {
-entry:
-  %0 = call i1 @"interface:{Error:func:{}{basic:string}}.$typeassert"(i32 %itf.typecode) #0
-  br i1 %0, label %typeassert.ok, label %typeassert.next

 typeassert.ok:                                    ; preds = %entry
  br label %typeassert.next
+}
+
+declare i1 @runtime.typeAssert(i32, i8* dereferenceable_or_null(1), i8*) #0
+
+; Function Attrs: nounwind
+define hidden i1 @main.isError(i32 %itf.typecode, i8* %itf.value, i8* %context) unnamed_addr #1 {
+entry:
+  %0 = call i1 @"interface:{Error:func:{}{basic:string}}.$typeassert"(i32 %itf.typecode) #6
+  br i1 %0, label %typeassert.ok, label %typeassert.next

 typeassert.next:                                  ; preds = %typeassert.ok, %entry
  ret i1 %0
-}
-
-; Function Attrs: nounwind
-define hidden i1 @main.isStringer(i32 %itf.typecode, i8* %itf.value, i8* %context) unnamed_addr #0 {
-entry:
-  %0 = call i1 @"interface:{String:func:{}{basic:string}}.$typeassert"(i32 %itf.typecode) #0
-  br i1 %0, label %typeassert.ok, label %typeassert.next

 typeassert.ok:                                    ; preds = %entry
  br label %typeassert.next
-
-typeassert.next:                                  ; preds = %typeassert.ok, %entry
-  ret i1 %0
 }

 ; Function Attrs: nounwind
-define hidden i8 @main.callFooMethod(i32 %itf.typecode, i8* %itf.value, i8* %context) unnamed_addr #0 {
+define hidden i1 @main.isStringer(i32 %itf.typecode, i8* %itf.value, i8* %context) unnamed_addr #1 {
 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 i1 @"interface:{String:func:{}{basic:string}}.$typeassert"(i32 %itf.typecode) #6
+  br i1 %0, label %typeassert.ok, label %typeassert.next
+
+typeassert.next:                                  ; preds = %typeassert.ok, %entry
+  ret i1 %0
+
+typeassert.ok:                                    ; preds = %entry
+  br label %typeassert.next
+}
+
+; Function Attrs: nounwind
+define hidden i8 @main.callFooMethod(i32 %itf.typecode, i8* %itf.value, i8* %context) unnamed_addr #1 {
+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) #6
  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*) #4

 ; 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) unnamed_addr #1 {
 entry:
-  %0 = call %runtime._string @"interface:{Error:func:{}{basic:string}}.Error$invoke"(i8* %itf.value, i32 %itf.typecode, i8* undef) #0
+  %0 = call %runtime._string @"interface:{Error:func:{}{basic:string}}.Error$invoke"(i8* %itf.value, i32 %itf.typecode, i8* undef) #6
  %1 = extractvalue %runtime._string %0, 0
-  call void @runtime.trackPointer(i8* %1, i8* undef) #0
+  call void @runtime.trackPointer(i8* %1, i8* undef) #6
  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*) #5

-attributes #0 = { nounwind }
-attributes #1 = { "tinygo-methods"="reflect/methods.Error() string" }
-attributes #2 = { "tinygo-methods"="reflect/methods.String() string" }
-attributes #3 = { "tinygo-invoke"="main.$methods.foo(int) byte" "tinygo-methods"="reflect/methods.String() string; main.$methods.foo(int) byte" }
-attributes #4 = { "tinygo-invoke"="reflect/methods.Error() string" "tinygo-methods"="reflect/methods.Error() string" }
+attributes #0 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #1 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #2 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "tinygo-methods"="reflect/methods.Error() string" }
+attributes #3 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "tinygo-methods"="reflect/methods.String() string" }
+attributes #4 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "tinygo-invoke"="main.$methods.foo(int) uint8" "tinygo-methods"="reflect/methods.String() string; main.$methods.foo(int) uint8" }
+attributes #5 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "tinygo-invoke"="reflect/methods.Error() string" "tinygo-methods"="reflect/methods.Error() string" }
+attributes #6 = { nounwind }
@@ -1,32 +0,0 @@
-; ModuleID = 'intrinsics.go'
-source_filename = "intrinsics.go"
-target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
-target triple = "thumbv7m-unknown-unknown-eabi"
-
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*)
-
-; Function Attrs: nounwind
-define hidden void @main.init(i8* %context) unnamed_addr #0 {
-entry:
-  ret void
-}
-
-; Function Attrs: nounwind
-define hidden double @main.mySqrt(double %x, i8* %context) unnamed_addr #0 {
-entry:
-  %0 = call double @math.Sqrt(double %x, i8* undef) #0
-  ret double %0
-}
-
-declare double @math.Sqrt(double, i8*)
-
-; Function Attrs: nounwind
-define hidden double @main.myTrunc(double %x, i8* %context) unnamed_addr #0 {
-entry:
-  %0 = call double @math.Trunc(double %x, i8* undef) #0
-  ret double %0
-}
-
-declare double @math.Trunc(double, i8*)
-
-attributes #0 = { nounwind }
@@ -1,37 +0,0 @@
-; 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 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 double @main.mySqrt(double %x, i8* %context) unnamed_addr #0 {
-entry:
-  %0 = call double @llvm.sqrt.f64(double %x)
-  ret double %0
-}
-
-; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
-declare double @llvm.sqrt.f64(double) #1
-
-; Function Attrs: nounwind
-define hidden double @main.myTrunc(double %x, i8* %context) unnamed_addr #0 {
-entry:
-  %0 = call double @llvm.trunc.f64(double %x)
-  ret double %0
-}
-
-; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
-declare double @llvm.trunc.f64(double) #1
-
-attributes #0 = { nounwind }
-attributes #1 = { nofree nosync nounwind readnone speculatable willreturn }
@@ -1,14 +0,0 @@
-package main
-
-// Test how intrinsics are lowered: either as regular calls to the math
-// functions or as LLVM builtins (such as llvm.sqrt.f64).
-
-import "math"
-
-func mySqrt(x float64) float64 {
-	return math.Sqrt(x)
-}
-
-func myTrunc(x float64) float64 {
-	return math.Trunc(x)
-}
@@ -1,78 +1,80 @@
 ; 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-p10:8:8-p20:8:8-i64:64-n32:64-S128-ni:1:10:20"
 target triple = "wasm32-unknown-wasi"

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

-declare void @runtime.trackPointer(i8* nocapture readonly, i8*)
+declare void @runtime.trackPointer(i8* nocapture readonly, i8*) #0

 ; Function Attrs: nounwind
-define hidden void @main.init(i8* %context) unnamed_addr #0 {
+define hidden void @main.init(i8* %context) unnamed_addr #1 {
 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) unnamed_addr #1 {
 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) unnamed_addr #1 {
 entry:
  %0 = bitcast i8* %x to i32*
-  call void @runtime.trackPointer(i8* %x, i8* undef) #0
+  call void @runtime.trackPointer(i8* %x, i8* undef) #2
  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) unnamed_addr #1 {
 entry:
  %0 = bitcast i32* %x to i8*
-  call void @runtime.trackPointer(i8* %0, i8* undef) #0
+  call void @runtime.trackPointer(i8* %0, i8* undef) #2
  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) unnamed_addr #1 {
 entry:
-  call void @runtime.trackPointer(i8* %x, i8* undef) #0
+  call void @runtime.trackPointer(i8* %x, i8* undef) #2
  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) unnamed_addr #1 {
 entry:
-  call void @runtime.trackPointer(i8* %ptr, i8* undef) #0
+  call void @runtime.trackPointer(i8* %ptr, i8* undef) #2
  %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
+  call void @runtime.trackPointer(i8* nonnull %0, i8* undef) #2
+  call void @runtime.trackPointer(i8* nonnull %0, i8* undef) #2
  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) unnamed_addr #1 {
 entry:
-  call void @runtime.trackPointer(i8* %ptr, i8* undef) #0
+  call void @runtime.trackPointer(i8* %ptr, i8* undef) #2
  %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
+  call void @runtime.trackPointer(i8* %0, i8* undef) #2
+  call void @runtime.trackPointer(i8* %0, i8* undef) #2
  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) unnamed_addr #1 {
 entry:
  %0 = bitcast i32* %ptr to i8*
-  call void @runtime.trackPointer(i8* %0, i8* undef) #0
+  call void @runtime.trackPointer(i8* %0, i8* undef) #2
  %1 = getelementptr i32, i32* %ptr, i32 %offset
  %2 = bitcast i32* %1 to i8*
-  call void @runtime.trackPointer(i8* %2, i8* undef) #0
+  call void @runtime.trackPointer(i8* %2, i8* undef) #2
  %3 = bitcast i32* %1 to i8*
-  call void @runtime.trackPointer(i8* %3, i8* undef) #0
+  call void @runtime.trackPointer(i8* %3, i8* undef) #2
  ret i32* %1
 }

-attributes #0 = { nounwind }
+attributes #0 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #1 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #2 = { nounwind }
@@ -3,44 +3,53 @@ package main
 import _ "unsafe"

 // Creates an external global with name extern_global.
+//
 //go:extern extern_global
 var externGlobal [0]byte

 // Creates a
+//
 //go:align 32
 var alignedGlobal [4]uint32

 // Test conflicting pragmas (the last one counts).
+//
 //go:align 64
 //go:align 16
 var alignedGlobal16 [4]uint32

 // Test exported functions.
+//
 //export extern_func
 func externFunc() {
 }

 // Define a function in a different package using go:linkname.
+//
 //go:linkname withLinkageName1 somepkg.someFunction1
 func withLinkageName1() {
 }

 // Import a function from a different package using go:linkname.
+//
 //go:linkname withLinkageName2 somepkg.someFunction2
 func withLinkageName2()

 // Function has an 'inline hint', similar to the inline keyword in C.
+//
 //go:inline
 func inlineFunc() {
 }

 // Function should never be inlined, equivalent to GCC
 // __attribute__((noinline)).
+//
 //go:noinline
 func noinlineFunc() {
 }

 // This function should have the specified section.
+//
 //go:section .special_function_section
 func functionInSection() {
 }
@@ -51,6 +60,7 @@ func exportedFunctionInSection() {
 }

 // This function should not: it's only a declaration and not a definition.
+//
 //go:section .special_function_section
 func undefinedFunctionNotInSection()

@@ -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-p10:8:8-p20:8:8-i64:64-n32:64-S128-ni:1:10:20"
 target triple = "wasm32-unknown-wasi"

@extern_global = external global [0 x i8], align 1
@@ -10,58 +10,59 @@ 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 noalias nonnull i8* @runtime.alloc(i32, i8*, i8*) #0

-declare void @runtime.trackPointer(i8* nocapture readonly, i8*)
+declare void @runtime.trackPointer(i8* nocapture readonly, i8*) #0

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

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

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

-declare void @somepkg.someFunction2(i8*)
+declare void @somepkg.someFunction2(i8*) #0

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

 ; Function Attrs: noinline nounwind
-define hidden void @main.noinlineFunc(i8* %context) unnamed_addr #3 {
+define hidden void @main.noinlineFunc(i8* %context) unnamed_addr #4 {
 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) unnamed_addr #1 section ".special_function_section" {
 entry:
  ret void
 }

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

-declare void @main.undefinedFunctionNotInSection(i8*)
+declare void @main.undefinedFunctionNotInSection(i8*) #0

-attributes #0 = { nounwind }
-attributes #1 = { nounwind "wasm-export-name"="extern_func" }
-attributes #2 = { inlinehint nounwind }
-attributes #3 = { noinline nounwind }
-attributes #4 = { nounwind "wasm-export-name"="exportedFunctionInSection" }
+attributes #0 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #1 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #2 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "wasm-export-name"="extern_func" "wasm-import-module"="env" "wasm-import-name"="extern_func" }
+attributes #3 = { inlinehint nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #4 = { noinline nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #5 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "wasm-export-name"="exportedFunctionInSection" "wasm-import-module"="env" "wasm-import-name"="exportedFunctionInSection" }
@@ -1,5 +1,7 @@
 package main

+import "unsafe"
+
 func sliceLen(ints []int) int {
 	return len(ints)
 }
@@ -41,3 +43,36 @@ func makeArraySlice(len int) [][3]byte {
 func makeInt32Slice(len int) []int32 {
 	return make([]int32, len)
 }
+
+func Add32(p unsafe.Pointer, len int) unsafe.Pointer {
+	return unsafe.Add(p, len)
+}
+
+func Add64(p unsafe.Pointer, len int64) unsafe.Pointer {
+	return unsafe.Add(p, len)
+}
+
+func SliceToArray(s []int) *[4]int {
+	return (*[4]int)(s)
+}
+
+func SliceToArrayConst() *[4]int {
+	s := make([]int, 6)
+	return (*[4]int)(s)
+}
+
+func SliceInt(ptr *int, len int) []int {
+	return unsafe.Slice(ptr, len)
+}
+
+func SliceUint16(ptr *byte, len uint16) []byte {
+	return unsafe.Slice(ptr, len)
+}
+
+func SliceUint64(ptr *int, len uint64) []int {
+	return unsafe.Slice(ptr, len)
+}
+
+func SliceInt64(ptr *int, len int64) []int {
+	return unsafe.Slice(ptr, len)
+}
@@ -1,53 +1,53 @@
 ; 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-p10:8:8-p20:8:8-i64:64-n32:64-S128-ni:1:10:20"
 target triple = "wasm32-unknown-wasi"

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

-declare void @runtime.trackPointer(i8* nocapture readonly, i8*)
+declare void @runtime.trackPointer(i8* nocapture readonly, i8*) #0

 ; Function Attrs: nounwind
-define hidden void @main.init(i8* %context) unnamed_addr #0 {
+define hidden void @main.init(i8* %context) unnamed_addr #1 {
 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) unnamed_addr #1 {
 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) unnamed_addr #1 {
 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) unnamed_addr #1 {
 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
-  unreachable
-
 lookup.next:                                      ; preds = %entry
  %0 = getelementptr inbounds i32, i32* %ints.data, i32 %index
  %1 = load i32, i32* %0, align 4
  ret i32 %1
+
+lookup.throw:                                     ; preds = %entry
+  call void @runtime.lookupPanic(i8* undef) #2
+  unreachable
 }

-declare void @runtime.lookupPanic(i8*)
+declare void @runtime.lookupPanic(i8*) #0

 ; 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) unnamed_addr #1 {
 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) #2
+  call void @runtime.trackPointer(i8* nonnull %varargs, i8* undef) #2
  %0 = bitcast i8* %varargs to i32*
  store i32 1, i32* %0, align 4
  %1 = getelementptr inbounds i8, i8* %varargs, i32 4
@@ -57,7 +57,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) #2
  %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 +65,18 @@ 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
+  call void @runtime.trackPointer(i8* %append.newPtr, i8* undef) #2
  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*) #0

 ; 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) unnamed_addr #1 {
 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) #2
  %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,103 +84,248 @@ 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
+  call void @runtime.trackPointer(i8* %append.newPtr, i8* undef) #2
  ret { i32*, i32, i32 } %2
 }

 ; Function Attrs: nounwind
-define hidden i32 @main.sliceCopy(i32* %dst.data, i32 %dst.len, i32 %dst.cap, i32* %src.data, i32 %src.len, i32 %src.cap, i8* %context) 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) unnamed_addr #1 {
 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) #2
  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*) #0

 ; 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) unnamed_addr #1 {
 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
-  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) #2
  %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
+  call void @runtime.trackPointer(i8* nonnull %makeslice.buf, i8* undef) #2
  ret { i8*, i32, i32 } %2
+
+slice.throw:                                      ; preds = %entry
+  call void @runtime.slicePanic(i8* undef) #2
+  unreachable
 }

-declare void @runtime.slicePanic(i8*)
+declare void @runtime.slicePanic(i8*) #0

 ; 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) unnamed_addr #1 {
 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
-  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) #2
  %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
+  call void @runtime.trackPointer(i8* nonnull %makeslice.buf, i8* undef) #2
  ret { i16*, i32, i32 } %2
+
+slice.throw:                                      ; preds = %entry
+  call void @runtime.slicePanic(i8* undef) #2
+  unreachable
 }

 ; 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) unnamed_addr #1 {
 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
-  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) #2
  %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
+  call void @runtime.trackPointer(i8* nonnull %makeslice.buf, i8* undef) #2
  ret { [3 x i8]*, i32, i32 } %2
+
+slice.throw:                                      ; preds = %entry
+  call void @runtime.slicePanic(i8* undef) #2
+  unreachable
 }

 ; 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) unnamed_addr #1 {
 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
-  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) #2
  %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
+  call void @runtime.trackPointer(i8* nonnull %makeslice.buf, i8* undef) #2
  ret { i32*, i32, i32 } %2
+
+slice.throw:                                      ; preds = %entry
+  call void @runtime.slicePanic(i8* undef) #2
+  unreachable
 }

-attributes #0 = { nounwind }
+; Function Attrs: nounwind
+define hidden i8* @main.Add32(i8* %p, i32 %len, i8* %context) unnamed_addr #1 {
+entry:
+  %0 = getelementptr i8, i8* %p, i32 %len
+  call void @runtime.trackPointer(i8* %0, i8* undef) #2
+  ret i8* %0
+}
+
+; Function Attrs: nounwind
+define hidden i8* @main.Add64(i8* %p, i64 %len, i8* %context) unnamed_addr #1 {
+entry:
+  %0 = trunc i64 %len to i32
+  %1 = getelementptr i8, i8* %p, i32 %0
+  call void @runtime.trackPointer(i8* %1, i8* undef) #2
+  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 #1 {
+entry:
+  %0 = icmp ult i32 %s.len, 4
+  br i1 %0, label %slicetoarray.throw, label %slicetoarray.next
+
+slicetoarray.next:                                ; preds = %entry
+  %1 = bitcast i32* %s.data to [4 x i32]*
+  ret [4 x i32]* %1
+
+slicetoarray.throw:                               ; preds = %entry
+  call void @runtime.sliceToArrayPointerPanic(i8* undef) #2
+  unreachable
+}
+
+declare void @runtime.sliceToArrayPointerPanic(i8*) #0
+
+; Function Attrs: nounwind
+define hidden [4 x i32]* @main.SliceToArrayConst(i8* %context) unnamed_addr #1 {
+entry:
+  %makeslice = call i8* @runtime.alloc(i32 24, i8* nonnull inttoptr (i32 3 to i8*), i8* undef) #2
+  call void @runtime.trackPointer(i8* nonnull %makeslice, i8* undef) #2
+  br i1 false, label %slicetoarray.throw, label %slicetoarray.next
+
+slicetoarray.next:                                ; preds = %entry
+  %0 = bitcast i8* %makeslice to [4 x i32]*
+  ret [4 x i32]* %0
+
+slicetoarray.throw:                               ; preds = %entry
+  unreachable
+}
+
+; Function Attrs: nounwind
+define hidden { i32*, i32, i32 } @main.SliceInt(i32* dereferenceable_or_null(4) %ptr, i32 %len, i8* %context) unnamed_addr #1 {
+entry:
+  %0 = icmp ugt i32 %len, 1073741823
+  %1 = icmp eq i32* %ptr, null
+  %2 = icmp ne i32 %len, 0
+  %3 = and i1 %1, %2
+  %4 = or i1 %3, %0
+  br i1 %4, label %unsafe.Slice.throw, label %unsafe.Slice.next
+
+unsafe.Slice.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) #2
+  ret { i32*, i32, i32 } %7
+
+unsafe.Slice.throw:                               ; preds = %entry
+  call void @runtime.unsafeSlicePanic(i8* undef) #2
+  unreachable
+}
+
+declare void @runtime.unsafeSlicePanic(i8*) #0
+
+; Function Attrs: nounwind
+define hidden { i8*, i32, i32 } @main.SliceUint16(i8* dereferenceable_or_null(1) %ptr, i16 %len, i8* %context) unnamed_addr #1 {
+entry:
+  %0 = icmp eq i8* %ptr, null
+  %1 = icmp ne i16 %len, 0
+  %2 = and i1 %0, %1
+  br i1 %2, label %unsafe.Slice.throw, label %unsafe.Slice.next
+
+unsafe.Slice.next:                                ; preds = %entry
+  %3 = zext i16 %len to i32
+  %4 = insertvalue { i8*, i32, i32 } undef, i8* %ptr, 0
+  %5 = insertvalue { i8*, i32, i32 } %4, i32 %3, 1
+  %6 = insertvalue { i8*, i32, i32 } %5, i32 %3, 2
+  call void @runtime.trackPointer(i8* %ptr, i8* undef) #2
+  ret { i8*, i32, i32 } %6
+
+unsafe.Slice.throw:                               ; preds = %entry
+  call void @runtime.unsafeSlicePanic(i8* undef) #2
+  unreachable
+}
+
+; Function Attrs: nounwind
+define hidden { i32*, i32, i32 } @main.SliceUint64(i32* dereferenceable_or_null(4) %ptr, i64 %len, i8* %context) unnamed_addr #1 {
+entry:
+  %0 = icmp ugt i64 %len, 1073741823
+  %1 = icmp eq i32* %ptr, null
+  %2 = icmp ne i64 %len, 0
+  %3 = and i1 %1, %2
+  %4 = or i1 %3, %0
+  br i1 %4, label %unsafe.Slice.throw, label %unsafe.Slice.next
+
+unsafe.Slice.next:                                ; preds = %entry
+  %5 = trunc i64 %len to i32
+  %6 = insertvalue { i32*, i32, i32 } undef, i32* %ptr, 0
+  %7 = insertvalue { i32*, i32, i32 } %6, i32 %5, 1
+  %8 = insertvalue { i32*, i32, i32 } %7, i32 %5, 2
+  %9 = bitcast i32* %ptr to i8*
+  call void @runtime.trackPointer(i8* %9, i8* undef) #2
+  ret { i32*, i32, i32 } %8
+
+unsafe.Slice.throw:                               ; preds = %entry
+  call void @runtime.unsafeSlicePanic(i8* undef) #2
+  unreachable
+}
+
+; Function Attrs: nounwind
+define hidden { i32*, i32, i32 } @main.SliceInt64(i32* dereferenceable_or_null(4) %ptr, i64 %len, i8* %context) unnamed_addr #1 {
+entry:
+  %0 = icmp ugt i64 %len, 1073741823
+  %1 = icmp eq i32* %ptr, null
+  %2 = icmp ne i64 %len, 0
+  %3 = and i1 %1, %2
+  %4 = or i1 %3, %0
+  br i1 %4, label %unsafe.Slice.throw, label %unsafe.Slice.next
+
+unsafe.Slice.next:                                ; preds = %entry
+  %5 = trunc i64 %len to i32
+  %6 = insertvalue { i32*, i32, i32 } undef, i32* %ptr, 0
+  %7 = insertvalue { i32*, i32, i32 } %6, i32 %5, 1
+  %8 = insertvalue { i32*, i32, i32 } %7, i32 %5, 2
+  %9 = bitcast i32* %ptr to i8*
+  call void @runtime.trackPointer(i8* %9, i8* undef) #2
+  ret { i32*, i32, i32 } %8
+
+unsafe.Slice.throw:                               ; preds = %entry
+  call void @runtime.unsafeSlicePanic(i8* undef) #2
+  unreachable
+}
+
+attributes #0 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #1 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #2 = { nounwind }
@@ -1,99 +1,101 @@
 ; 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-p10:8:8-p20:8:8-i64:64-n32:64-S128-ni:1:10:20"
 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 noalias nonnull i8* @runtime.alloc(i32, i8*, i8*) #0

-declare void @runtime.trackPointer(i8* nocapture readonly, i8*)
+declare void @runtime.trackPointer(i8* nocapture readonly, i8*) #0

 ; Function Attrs: nounwind
-define hidden void @main.init(i8* %context) unnamed_addr #0 {
+define hidden void @main.init(i8* %context) unnamed_addr #1 {
 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) unnamed_addr #1 {
 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) unnamed_addr #1 {
 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) unnamed_addr #1 {
 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) unnamed_addr #1 {
 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
-  unreachable
-
 lookup.next:                                      ; preds = %entry
  %0 = getelementptr inbounds i8, i8* %s.data, i32 %index
  %1 = load i8, i8* %0, align 1
  ret i8 %1
+
+lookup.throw:                                     ; preds = %entry
+  call void @runtime.lookupPanic(i8* undef) #2
+  unreachable
 }

-declare void @runtime.lookupPanic(i8*)
+declare void @runtime.lookupPanic(i8*) #0

 ; 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) unnamed_addr #1 {
 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) #2
  ret i1 %0
 }

-declare i1 @runtime.stringEqual(i8*, i32, i8*, i32, i8*)
+declare i1 @runtime.stringEqual(i8*, i32, i8*, i32, i8*) #0

 ; 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) unnamed_addr #1 {
 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) #2
  %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) unnamed_addr #1 {
 entry:
-  %0 = call i1 @runtime.stringLess(i8* %s2.data, i32 %s2.len, i8* %s1.data, i32 %s1.len, i8* undef) #0
+  %0 = call i1 @runtime.stringLess(i8* %s2.data, i32 %s2.len, i8* %s1.data, i32 %s1.len, i8* undef) #2
  ret i1 %0
 }

-declare i1 @runtime.stringLess(i8*, i32, i8*, i32, i8*)
+declare i1 @runtime.stringLess(i8*, i32, i8*, i32, i8*) #0

 ; 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) unnamed_addr #1 {
 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
-  unreachable
-
 lookup.next:                                      ; preds = %entry
  %1 = getelementptr inbounds i8, i8* %s.data, i32 %0
  %2 = load i8, i8* %1, align 1
  ret i8 %2
+
+lookup.throw:                                     ; preds = %entry
+  call void @runtime.lookupPanic(i8* undef) #2
+  unreachable
 }

-attributes #0 = { nounwind }
+attributes #0 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #1 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #2 = { nounwind }
@@ -3,28 +3,25 @@ package compiler
 // This file implements volatile loads/stores in runtime/volatile.LoadT and
 // runtime/volatile.StoreT as compiler builtins.

-import (
-	"golang.org/x/tools/go/ssa"
-	"tinygo.org/x/go-llvm"
-)
-
 // createVolatileLoad is the implementation of the intrinsic function
 // runtime/volatile.LoadT().
-func (b *builder) createVolatileLoad(instr *ssa.CallCommon) (llvm.Value, error) {
-	addr := b.getValue(instr.Args[0])
-	b.createNilCheck(instr.Args[0], addr, "deref")
+func (b *builder) createVolatileLoad() {
+	b.createFunctionStart(true)
+	addr := b.getValue(b.fn.Params[0])
+	b.createNilCheck(b.fn.Params[0], addr, "deref")
 	val := b.CreateLoad(addr, "")
 	val.SetVolatile(true)
-	return val, nil
+	b.CreateRet(val)
 }

 // createVolatileStore is the implementation of the intrinsic function
 // runtime/volatile.StoreT().
-func (b *builder) createVolatileStore(instr *ssa.CallCommon) (llvm.Value, error) {
-	addr := b.getValue(instr.Args[0])
-	val := b.getValue(instr.Args[1])
-	b.createNilCheck(instr.Args[0], addr, "deref")
+func (b *builder) createVolatileStore() {
+	b.createFunctionStart(true)
+	addr := b.getValue(b.fn.Params[0])
+	val := b.getValue(b.fn.Params[1])
+	b.createNilCheck(b.fn.Params[0], addr, "deref")
 	store := b.CreateStore(val, addr)
 	store.SetVolatile(true)
-	return llvm.Value{}, nil
+	b.CreateRetVoid()
 }
@@ -8,6 +8,7 @@ import (
 	"sync"
 	"testing"

+	"golang.org/x/tools/go/buildutil"
 	yaml "gopkg.in/yaml.v2"
 )

@@ -111,9 +112,11 @@ func TestCorpus(t *testing.T) {

 				opts := optionsFromTarget(target, sema)
 				opts.Directory = dir
-				opts.Tags = repo.Tags
+				var tags buildutil.TagsFlag
+				tags.Set(repo.Tags)
+				opts.Tags = []string(tags)

-				passed, err := Test(path, out, out, &opts, false, testing.Verbose(), false, "", "", "", "")
+				passed, err := Test(path, out, out, &opts, false, testing.Verbose(), false, "", "", "", false, "")
 				if err != nil {
 					t.Errorf("test error: %v", err)
 				}
@@ -1,9 +1,9 @@
 module github.com/tinygo-org/tinygo

-go 1.15
+go 1.18

 require (
-	github.com/aykevl/go-wasm v0.0.2-0.20211119014117-0761b1ddcd1a
+	github.com/aykevl/go-wasm v0.0.2-0.20220616010729-4a0a888aebdc
 	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
@@ -11,9 +11,21 @@ require (
 	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/tools v0.1.6-0.20210813165731-45389f592fe9
+	go.bug.st/serial v1.3.5
+	golang.org/x/sys v0.0.0-20220829200755-d48e67d00261
+	golang.org/x/tools v0.1.11
 	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-20220802112859-5bb0b77907a7
+)
+
+require (
+	github.com/chromedp/sysutil v1.0.0 // indirect
+	github.com/creack/goselect v0.1.2 // indirect
+	github.com/gobwas/httphead v0.1.0 // indirect
+	github.com/gobwas/pool v0.2.1 // indirect
+	github.com/gobwas/ws v1.1.0 // indirect
+	github.com/josharian/intern v1.0.0 // indirect
+	github.com/mailru/easyjson v0.7.7 // indirect
+	github.com/mattn/go-isatty v0.0.12 // indirect
+	golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4 // indirect
 )
@@ -1,5 +1,5 @@
-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.20220616010729-4a0a888aebdc h1:Yp49g+qqgQRPk/gcRSmAsXgnT16XPJ6Y5JM1poc6gYM=
+github.com/aykevl/go-wasm v0.0.2-0.20220616010729-4a0a888aebdc/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=
@@ -40,45 +40,27 @@ github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZN
 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/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.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+go.bug.st/serial v1.3.5 h1:k50SqGZCnHZ2MiBQgzccXWG+kd/XpOs1jUljpDDKzaE=
+go.bug.st/serial v1.3.5/go.mod h1:z8CesKorE90Qr/oRSJiEuvzYRKol9r/anJZEb5kt304=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4 h1:6zppjxzCulZykYSLyVDYbneBfbaBIQPYMevg0bEwv2s=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
 golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200909081042-eff7692f9009/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201207223542-d4d67f95c62d/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/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=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.1.6-0.20210813165731-45389f592fe9 h1:nvvuMxmx1q0gfRki3T0hjG8EwAcVCs91oWAXvyt4zhI=
-golang.org/x/tools v0.1.6-0.20210813165731-45389f592fe9/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/sys v0.0.0-20220829200755-d48e67d00261 h1:v6hYoSR9T5oet+pMXwUWkbiVqx/63mlHjefrHmxwfeY=
+golang.org/x/sys v0.0.0-20220829200755-d48e67d00261/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/tools v0.1.11 h1:loJ25fNOEhSXfHrpoGj91eCUThwdNX6u24rO1xnNteY=
+golang.org/x/tools v0.1.11/go.mod h1:SgwaegtQh8clINPpECJMqnxLv9I09HLqnW3RMqW0CA4=
 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-20220802112859-5bb0b77907a7 h1:nSLR52mUw7DPQQVA3ZJFH63zjU4ME84fKiin6mdnYWc=
+tinygo.org/x/go-llvm v0.0.0-20220802112859-5bb0b77907a7/go.mod h1:GFbusT2VTA4I+l4j80b17KFK+6whv69Wtny5U+T8RR0=
--- a/Show More
+++ b/Show More