usb/msc: wait for interrupt instead of polling a flag

This should make usb/msc a whole lot more efficient by pausing the
worker goroutine and waiting for an interrupt to unpause it instead of
waiting in a loop and sleeping for 0.1ms each cycle.

In other words, this should make it both faster (no unnecessary delay
due to the time.Sleep) and more efficient (no polling).

.circleci/config.yml

@@ -1,119 +0,0 @@
-version: 2.1
-
-commands:
-  submodules:
-    steps:
-      - run:
-          name: "Pull submodules"
-          command: git submodule update --init
-  llvm-source-linux:
-    steps:
-      - restore_cache:
-          keys:
-            - llvm-source-19-v1
-      - run:
-          name: "Fetch LLVM source"
-          command: make llvm-source
-      - save_cache:
-          key: llvm-source-19-v1
-          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:
-    steps:
-      - run:
-          name: "Hack Ninja to use less jobs"
-          command: |
-            echo -e '#!/bin/sh\n/usr/bin/ninja -j3 "$@"' > /go/bin/ninja
-            chmod +x /go/bin/ninja
-  build-binaryen-linux:
-    steps:
-      - restore_cache:
-          keys:
-            - binaryen-linux-v3
-      - run:
-          name: "Build Binaryen"
-          command: |
-            make binaryen
-      - save_cache:
-          key: binaryen-linux-v3
-          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/bullseye/ llvm-toolchain-bullseye-<<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 \
-                lld-<<parameters.llvm>> \
-                cmake \
-                ninja-build
-      - hack-ninja-jobs
-      - build-binaryen-linux
-      - restore_cache:
-          keys:
-            - go-cache-v4-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_PREVIOUS_BUILD_NUM }}
-            - go-cache-v4-{{ checksum "go.mod" }}
-      - llvm-source-linux
-      - run: go install -tags=llvm<<parameters.llvm>> .
-      - 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 lint
-      - run: make gen-device -j4
-      # TODO: change this to -skip='TestErrors|TestWasm' with Go 1.20
-      - run: go test -tags=llvm<<parameters.llvm>> -short -run='TestBuild|TestTest|TestGetList|TestTraceback'
-      - run: make smoketest XTENSA=0
-      - save_cache:
-          key: go-cache-v4-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_BUILD_NUM }}
-          paths:
-            - ~/.cache/go-build
-            - /go/pkg/mod
-
-jobs:
-  test-oldest:
-    # This tests our lowest supported versions of Go and LLVM, to make sure at
-    # least the smoke tests still pass.
-    docker:
-      - image: golang:1.22-bullseye
-    steps:
-      - test-linux:
-          llvm: "15"
-    resource_class: large
-  test-newest:
-    # This tests the latest supported LLVM version when linking against system
-    # libraries.
-    docker:
-      - image: golang:1.25-bullseye
-    steps:
-      - test-linux:
-          llvm: "20"
-    resource_class: large
-
-workflows:
-  test-all:
-    jobs:
-      - test-oldest
-      # disable this test, since CircleCI seems unable to download due to rate-limits on Dockerhub.
-      # - test-newest

.dockerignore

@@ -1,5 +1,4 @@
 build/
 llvm-*/
 .github
-.circleci
 

.github/workflows/build-macos.yml

@@ -31,7 +31,7 @@ jobs:
         run: |
           HOMEBREW_NO_AUTO_UPDATE=1 brew install qemu binaryen
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Extract TinyGo version
@@ -40,10 +40,10 @@ jobs:
       - name: Install Go
         uses: actions/setup-go@v6
         with:
-          go-version: '1.25.5'
+          go-version: '1.26.2'
           cache: true
       - name: Restore LLVM source cache
-        uses: actions/cache/restore@v4
+        uses: actions/cache/restore@v5
         id: cache-llvm-source
         with:
           key: llvm-source-20-${{ matrix.os }}-v1
@@ -57,7 +57,7 @@ jobs:
         if: steps.cache-llvm-source.outputs.cache-hit != 'true'
         run: make llvm-source
       - name: Save LLVM source cache
-        uses: actions/cache/save@v4
+        uses: actions/cache/save@v5
         if: steps.cache-llvm-source.outputs.cache-hit != 'true'
         with:
           key: ${{ steps.cache-llvm-source.outputs.cache-primary-key }}
@@ -68,7 +68,7 @@ jobs:
             llvm-project/lld/include
             llvm-project/llvm/include
       - name: Restore LLVM build cache
-        uses: actions/cache/restore@v4
+        uses: actions/cache/restore@v5
         id: cache-llvm-build
         with:
           key: llvm-build-20-${{ matrix.os }}-v2
@@ -85,7 +85,7 @@ jobs:
           make llvm-build
           find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
       - name: Save LLVM build cache
-        uses: actions/cache/save@v4
+        uses: actions/cache/save@v5
         if: steps.cache-llvm-build.outputs.cache-hit != 'true'
         with:
           key: ${{ steps.cache-llvm-build.outputs.cache-primary-key }}
@@ -101,16 +101,11 @@ jobs:
       - name: Make release artifact
         run: cp -p build/release.tar.gz build/tinygo${{ steps.version.outputs.version }}.darwin-${{ matrix.goarch }}.tar.gz
       - name: Publish release artifact
-        # Note: this release artifact is double-zipped, see:
-        # https://github.com/actions/upload-artifact/issues/39
-        # We can essentially pick one of these:
-        # - have a double-zipped artifact when downloaded from the UI
-        # - have a very slow artifact upload
-        # We're doing the former here, to keep artifact uploads fast.
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v7
         with:
           name: darwin-${{ matrix.goarch }}-double-zipped-${{ steps.version.outputs.version }}
           path: build/tinygo${{ steps.version.outputs.version }}.darwin-${{ matrix.goarch }}.tar.gz
+          archive: false
       - name: Smoke tests
         run: make smoketest TINYGO=$(PWD)/build/tinygo
   test-macos-homebrew:
@@ -121,7 +116,7 @@ jobs:
         version: [16, 17, 18, 19, 20]
     steps:
       - name: Set up Homebrew
-        uses: Homebrew/actions/setup-homebrew@master
+        uses: Homebrew/actions/setup-homebrew@main
       - name: Fix Python symlinks
         run: |
           # Github runners have broken symlinks, so relink
@@ -130,12 +125,13 @@ jobs:
       - name: Install LLVM
         run: |
           brew install llvm@${{ matrix.version }}
+          brew link llvm@${{ matrix.version }}
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: Install Go
         uses: actions/setup-go@v6
         with:
-          go-version: '1.25.5'
+          go-version: '1.26.2'
           cache: true
       - name: Build TinyGo (LLVM ${{ matrix.version }})
         run: go install -tags=llvm${{ matrix.version }}

.github/workflows/docker.yml

@@ -31,14 +31,14 @@ jobs:
           sudo rm -rf /usr/local/share/boost
           df -h
       - name: Check out the repo
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
         with:
           submodules: recursive
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
+        uses: docker/setup-buildx-action@v4
       - name: Docker meta
         id: meta
-        uses: docker/metadata-action@v5
+        uses: docker/metadata-action@v6
         with:
           images: |
             tinygo/tinygo-dev
@@ -47,18 +47,18 @@ jobs:
             type=sha,format=long
             type=raw,value=latest
       - name: Log in to Docker Hub
-        uses: docker/login-action@v3
+        uses: docker/login-action@v4
         with:
           username: ${{ secrets.DOCKER_HUB_USERNAME }}
           password: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}
       - name: Log in to Github Container Registry
-        uses: docker/login-action@v3
+        uses: docker/login-action@v4
         with:
           registry: ghcr.io
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
       - name: Build and push
-        uses: docker/build-push-action@v6
+        uses: docker/build-push-action@v7
         with:
           context: .
           push: true

.github/workflows/linux.yml

@@ -18,12 +18,12 @@ jobs:
     # statically linked binary.
     runs-on: ubuntu-latest
     container:
-      image: golang:1.25-alpine
+      image: golang:1.26-alpine
     outputs:
       version: ${{ steps.version.outputs.version }}
     steps:
       - name: Install apk dependencies
-        # tar: needed for actions/cache@v4
+        # tar: needed for actions/cache@v5
         # git+openssh: needed for checkout (I think?)
         # ruby: needed to install fpm
         run: apk add tar git openssh make g++ ruby-dev mold
@@ -31,24 +31,24 @@ jobs:
         # 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@v5
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Extract TinyGo version
         id: version
         run: ./.github/workflows/tinygo-extract-version.sh | tee -a "$GITHUB_OUTPUT"
       - name: Cache Go
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         with:
-          key: go-cache-linux-alpine-v1-${{ hashFiles('go.mod') }}
+          key: go-cache-linux-alpine-v2-${{ hashFiles('go.mod') }}
           path: |
             ~/.cache/go-build
             ~/go/pkg/mod
       - name: Restore LLVM source cache
-        uses: actions/cache/restore@v4
+        uses: actions/cache/restore@v5
         id: cache-llvm-source
         with:
-          key: llvm-source-20-linux-alpine-v1
+          key: llvm-source-20-linux-alpine-v2
           path: |
             llvm-project/clang/lib/Headers
             llvm-project/clang/include
@@ -59,7 +59,7 @@ jobs:
         if: steps.cache-llvm-source.outputs.cache-hit != 'true'
         run: make llvm-source
       - name: Save LLVM source cache
-        uses: actions/cache/save@v4
+        uses: actions/cache/save@v5
         if: steps.cache-llvm-source.outputs.cache-hit != 'true'
         with:
           key: ${{ steps.cache-llvm-source.outputs.cache-primary-key }}
@@ -70,10 +70,10 @@ jobs:
             llvm-project/lld/include
             llvm-project/llvm/include
       - name: Restore LLVM build cache
-        uses: actions/cache/restore@v4
+        uses: actions/cache/restore@v5
         id: cache-llvm-build
         with:
-          key: llvm-build-20-linux-alpine-v1
+          key: llvm-build-20-linux-alpine-v2
           path: llvm-build
       - name: Build LLVM
         if: steps.cache-llvm-build.outputs.cache-hit != 'true'
@@ -88,16 +88,16 @@ jobs:
           # Remove unnecessary object files (to reduce cache size).
           find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
       - name: Save LLVM build cache
-        uses: actions/cache/save@v4
+        uses: actions/cache/save@v5
         if: steps.cache-llvm-build.outputs.cache-hit != 'true'
         with:
           key: ${{ steps.cache-llvm-build.outputs.cache-primary-key }}
           path: llvm-build
       - name: Cache Binaryen
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         id: cache-binaryen
         with:
-          key: binaryen-linux-alpine-v1
+          key: binaryen-linux-alpine-v2
           path: build/wasm-opt
       - name: Build Binaryen
         if: steps.cache-binaryen.outputs.cache-hit != 'true'
@@ -118,26 +118,31 @@ jobs:
           make release deb -j3 STATIC=1
           cp -p build/release.tar.gz /tmp/tinygo${{ steps.version.outputs.version }}.linux-amd64.tar.gz
           cp -p build/release.deb    /tmp/tinygo_${{ steps.version.outputs.version }}_amd64.deb
-      - name: Publish release artifact
-        uses: actions/upload-artifact@v4
+      - name: "Publish release artifact: tarball"
+        uses: actions/upload-artifact@v7
         with:
-          name: linux-amd64-double-zipped-${{ steps.version.outputs.version }}
-          path: |
-            /tmp/tinygo${{ steps.version.outputs.version }}.linux-amd64.tar.gz
-            /tmp/tinygo_${{ steps.version.outputs.version }}_amd64.deb
+          name: tinygo${{ steps.version.outputs.version }}.linux-amd64.tar.gz
+          path: /tmp/tinygo${{ steps.version.outputs.version }}.linux-amd64.tar.gz
+          archive: false
+      - name: "Publish release artifact: Debian package"
+        uses: actions/upload-artifact@v7
+        with:
+          name: tinygo_${{ steps.version.outputs.version }}_amd64.deb
+          path: /tmp/tinygo_${{ steps.version.outputs.version }}_amd64.deb
+          archive: false
   test-linux-build:
     # Test the binaries built in the build-linux job by running the smoke tests.
     runs-on: ubuntu-latest
     needs: build-linux
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Install Go
         uses: actions/setup-go@v6
         with:
-          go-version: '1.25.5'
+          go-version: '1.26.2'
           cache: true
       - name: Install wasmtime
         uses: bytecodealliance/actions/wasmtime/setup@v1
@@ -146,9 +151,9 @@ jobs:
       - name: Install wasm-tools
         uses: bytecodealliance/actions/wasm-tools/setup@v1
       - name: Download release artifact
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v8
         with:
-          name: linux-amd64-double-zipped-${{ needs.build-linux.outputs.version }}
+          name: tinygo${{ needs.build-linux.outputs.version }}.linux-amd64.tar.gz
       - name: Extract release tarball
         run: |
           mkdir -p ~/lib
@@ -164,7 +169,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Install apt dependencies
@@ -181,10 +186,10 @@ jobs:
       - name: Install Go
         uses: actions/setup-go@v6
         with:
-          go-version: '1.25.5'
+          go-version: '1.26.2'
           cache: true
       - name: Install Node.js
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v6
         with:
           node-version: '18'
       - name: Install wasmtime
@@ -194,7 +199,7 @@ jobs:
       - name: Setup `wasm-tools`
         uses: bytecodealliance/actions/wasm-tools/setup@v1
       - name: Restore LLVM source cache
-        uses: actions/cache/restore@v4
+        uses: actions/cache/restore@v5
         id: cache-llvm-source
         with:
           key: llvm-source-20-linux-asserts-v1
@@ -208,7 +213,7 @@ jobs:
         if: steps.cache-llvm-source.outputs.cache-hit != 'true'
         run: make llvm-source
       - name: Save LLVM source cache
-        uses: actions/cache/save@v4
+        uses: actions/cache/save@v5
         if: steps.cache-llvm-source.outputs.cache-hit != 'true'
         with:
           key: ${{ steps.cache-llvm-source.outputs.cache-primary-key }}
@@ -219,7 +224,7 @@ jobs:
             llvm-project/lld/include
             llvm-project/llvm/include
       - name: Restore LLVM build cache
-        uses: actions/cache/restore@v4
+        uses: actions/cache/restore@v5
         id: cache-llvm-build
         with:
           key: llvm-build-20-linux-asserts-v1
@@ -235,13 +240,13 @@ jobs:
           # Remove unnecessary object files (to reduce cache size).
           find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
       - name: Save LLVM build cache
-        uses: actions/cache/save@v4
+        uses: actions/cache/save@v5
         if: steps.cache-llvm-build.outputs.cache-hit != 'true'
         with:
           key: ${{ steps.cache-llvm-build.outputs.cache-primary-key }}
           path: llvm-build
       - name: Cache Binaryen
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         id: cache-binaryen
         with:
           key: binaryen-linux-asserts-v1
@@ -284,7 +289,7 @@ jobs:
     needs: build-linux
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: Get TinyGo version
         id: version
         run: ./.github/workflows/tinygo-extract-version.sh | tee -a "$GITHUB_OUTPUT"
@@ -298,10 +303,10 @@ jobs:
       - name: Install Go
         uses: actions/setup-go@v6
         with:
-          go-version: '1.25.5'
+          go-version: '1.26.2'
           cache: true
       - name: Restore LLVM source cache
-        uses: actions/cache/restore@v4
+        uses: actions/cache/restore@v5
         id: cache-llvm-source
         with:
           key: llvm-source-20-linux-v1
@@ -315,7 +320,7 @@ jobs:
         if: steps.cache-llvm-source.outputs.cache-hit != 'true'
         run: make llvm-source
       - name: Save LLVM source cache
-        uses: actions/cache/save@v4
+        uses: actions/cache/save@v5
         if: steps.cache-llvm-source.outputs.cache-hit != 'true'
         with:
           key: ${{ steps.cache-llvm-source.outputs.cache-primary-key }}
@@ -326,7 +331,7 @@ jobs:
             llvm-project/lld/include
             llvm-project/llvm/include
       - name: Restore LLVM build cache
-        uses: actions/cache/restore@v4
+        uses: actions/cache/restore@v5
         id: cache-llvm-build
         with:
           key: llvm-build-20-linux-${{ matrix.goarch }}-v1
@@ -344,13 +349,13 @@ jobs:
           # Remove unnecessary object files (to reduce cache size).
           find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
       - name: Save LLVM build cache
-        uses: actions/cache/save@v4
+        uses: actions/cache/save@v5
         if: steps.cache-llvm-build.outputs.cache-hit != 'true'
         with:
           key: ${{ steps.cache-llvm-build.outputs.cache-primary-key }}
           path: llvm-build
       - name: Cache Binaryen
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         id: cache-binaryen
         with:
           key: binaryen-linux-${{ matrix.goarch }}-v4
@@ -370,9 +375,9 @@ jobs:
         run: |
           make CROSS=${{ matrix.toolchain }}
       - name: Download amd64 release
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v8
         with:
-          name: linux-amd64-double-zipped-${{ needs.build-linux.outputs.version }}
+          name: tinygo${{ needs.build-linux.outputs.version }}.linux-amd64.tar.gz
       - name: Extract amd64 release
         run: |
           mkdir -p build/release
@@ -384,12 +389,17 @@ jobs:
       - name: Create ${{ matrix.goarch }} release
         run: |
           make release deb RELEASEONLY=1 DEB_ARCH=${{ matrix.libc }}
-          cp -p build/release.tar.gz /tmp/tinygo${{ steps.version.outputs.version }}.linux-${{ matrix.goarch }}.tar.gz
-          cp -p build/release.deb    /tmp/tinygo_${{ steps.version.outputs.version }}_${{ matrix.libc }}.deb
-      - name: Publish release artifact
-        uses: actions/upload-artifact@v4
+          cp -p build/release.tar.gz /tmp/tinygo${{ needs.build-linux.outputs.version }}.linux-${{ matrix.goarch }}.tar.gz
+          cp -p build/release.deb    /tmp/tinygo_${{ needs.build-linux.outputs.version }}_${{ matrix.libc }}.deb
+      - name: "Publish release artifact: tarball"
+        uses: actions/upload-artifact@v7
         with:
-          name: linux-${{ matrix.goarch }}-double-zipped-${{ steps.version.outputs.version }}
-          path: |
-            /tmp/tinygo${{ steps.version.outputs.version }}.linux-${{ matrix.goarch }}.tar.gz
-            /tmp/tinygo_${{ steps.version.outputs.version }}_${{ matrix.libc }}.deb
+          name: linux-${{ matrix.goarch }}-double-zipped-${{ needs.build-linux.outputs.version }}
+          path: /tmp/tinygo${{ needs.build-linux.outputs.version }}.linux-${{ matrix.goarch }}.tar.gz
+          archive: false
+      - name: "Publish release artifact: Debian package"
+        uses: actions/upload-artifact@v7
+        with:
+          name: linux-${{ matrix.goarch }}-double-zipped-${{ needs.build-linux.outputs.version }}
+          path: /tmp/tinygo_${{ needs.build-linux.outputs.version }}_${{ matrix.libc }}.deb
+          archive: false

.github/workflows/llvm.yml

@@ -25,14 +25,14 @@ jobs:
       contents: read
     steps:
       - name: Check out the repo
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
         with:
           submodules: recursive
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
+        uses: docker/setup-buildx-action@v4
       - name: Docker meta
         id: meta
-        uses: docker/metadata-action@v5
+        uses: docker/metadata-action@v6
         with:
           images: |
             tinygo/llvm-20
@@ -46,13 +46,13 @@ jobs:
           username: ${{ secrets.DOCKER_HUB_USERNAME }}
           password: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}
       - name: Log in to Github Container Registry
-        uses: docker/login-action@v3
+        uses: docker/login-action@v4
         with:
           registry: ghcr.io
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
       - name: Build and push
-        uses: docker/build-push-action@v6
+        uses: docker/build-push-action@v7
         with:
           target: tinygo-llvm-build
           context: .

.github/workflows/nix.yml

@@ -21,12 +21,12 @@ jobs:
         # See: https://github.com/tinygo-org/tinygo/pull/4516#issuecomment-2416363668
         run: sudo apt-get remove llvm-18
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: Pull musl, bdwgc
         run: |
             git submodule update --init lib/musl lib/bdwgc
       - name: Restore LLVM source cache
-        uses: actions/cache/restore@v4
+        uses: actions/cache/restore@v5
         id: cache-llvm-source
         with:
           key: llvm-source-20-linux-nix-v1
@@ -36,13 +36,13 @@ jobs:
         if: steps.cache-llvm-source.outputs.cache-hit != 'true'
         run: make llvm-source
       - name: Save LLVM source cache
-        uses: actions/cache/save@v4
+        uses: actions/cache/save@v5
         if: steps.cache-llvm-source.outputs.cache-hit != 'true'
         with:
           key: ${{ steps.cache-llvm-source.outputs.cache-primary-key }}
           path: |
             llvm-project/compiler-rt
-      - uses: cachix/install-nix-action@v22
+      - uses: cachix/install-nix-action@v31
       - name: Test
         run: |
           nix develop --ignore-environment --keep HOME --command bash -c "go install && ~/go/bin/tinygo version && ~/go/bin/tinygo build -o test ./testdata/cgo"

.github/workflows/sizediff.yml

@@ -20,14 +20,14 @@ jobs:
         run: |
           echo "$HOME/go/bin" >> $GITHUB_PATH
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
         with:
           fetch-depth: 0 # fetch all history (no sparse checkout)
           submodules: true
       - name: Install apt dependencies
         run: ./.github/workflows/sizediff-install-pkgs.sh
       - name: Restore LLVM source cache
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         id: cache-llvm-source
         with:
           key: llvm-source-20-sizediff-v1
@@ -37,7 +37,7 @@ jobs:
         if: steps.cache-llvm-source.outputs.cache-hit != 'true'
         run: make llvm-source
       - name: Cache Go
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         with:
           key: go-cache-linux-sizediff-v2-${{ hashFiles('go.mod') }}
           path: |

.github/workflows/windows.yml

@@ -24,14 +24,13 @@ jobs:
           maximum-size: 24GB
           disk-root: "C:"
       - uses: MinoruSekine/setup-scoop@v4
-        with:
-          scoop_update: 'false'
       - name: Install Dependencies
         shell: bash
         run: |
+          scoop config use_external_7zip true
           scoop install ninja binaryen
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
         with:
           submodules: true
       - name: Extract TinyGo version
@@ -41,10 +40,10 @@ jobs:
       - name: Install Go
         uses: actions/setup-go@v6
         with:
-          go-version: '1.25.5'
+          go-version: '1.26.2'
           cache: true
       - name: Restore cached LLVM source
-        uses: actions/cache/restore@v4
+        uses: actions/cache/restore@v5
         id: cache-llvm-source
         with:
           key: llvm-source-20-windows-v1
@@ -58,7 +57,7 @@ jobs:
         if: steps.cache-llvm-source.outputs.cache-hit != 'true'
         run: make llvm-source
       - name: Save cached LLVM source
-        uses: actions/cache/save@v4
+        uses: actions/cache/save@v5
         if: steps.cache-llvm-source.outputs.cache-hit != 'true'
         with:
           key: ${{ steps.cache-llvm-source.outputs.cache-primary-key }}
@@ -69,7 +68,7 @@ jobs:
             llvm-project/lld/include
             llvm-project/llvm/include
       - name: Restore cached LLVM build
-        uses: actions/cache/restore@v4
+        uses: actions/cache/restore@v5
         id: cache-llvm-build
         with:
           key: llvm-build-20-windows-v2
@@ -86,20 +85,21 @@ jobs:
           # Remove unnecessary object files (to reduce cache size).
           find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
       - name: Save cached LLVM build
-        uses: actions/cache/save@v4
+        uses: actions/cache/save@v5
         if: steps.cache-llvm-build.outputs.cache-hit != 'true'
         with:
           key: ${{ steps.cache-llvm-build.outputs.cache-primary-key }}
           path: llvm-build
       - name: Cache Go cache
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         with:
-          key: go-cache-windows-v1-${{ hashFiles('go.mod') }}
+          key: go-cache-windows-v2-${{ hashFiles('go.mod') }}
           path: |
             C:/Users/runneradmin/AppData/Local/go-build
             C:/Users/runneradmin/go/pkg/mod
       - name: Install wasmtime
         run: |
+          scoop config use_external_7zip true
           scoop install wasmtime@29.0.1
       - name: make gen-device
         run: make -j3 gen-device
@@ -114,16 +114,11 @@ jobs:
         working-directory: build/release
         run: 7z -tzip a tinygo${{ steps.version.outputs.version }}.windows-amd64.zip tinygo
       - name: Publish release artifact
-        # Note: this release artifact is double-zipped, see:
-        # https://github.com/actions/upload-artifact/issues/39
-        # We can essentially pick one of these:
-        # - have a dobule-zipped artifact when downloaded from the UI
-        # - have a very slow artifact upload
-        # We're doing the former here, to keep artifact uploads fast.
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v7
         with:
-          name: windows-amd64-double-zipped-${{ steps.version.outputs.version }}
+          name: tinygo${{ steps.version.outputs.version }}.windows-amd64.zip
           path: build/release/tinygo${{ steps.version.outputs.version }}.windows-amd64.zip
+          archive: false
 
   smoke-test-windows:
     runs-on: windows-2022
@@ -136,28 +131,24 @@ jobs:
           maximum-size: 24GB
           disk-root: "C:"
       - uses: MinoruSekine/setup-scoop@v4
-        with:
-          scoop_update: 'false'
       - name: Install Dependencies
         shell: bash
         run: |
+          scoop config use_external_7zip true
           scoop install binaryen
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: Install Go
         uses: actions/setup-go@v6
         with:
-          go-version: '1.25.5'
+          go-version: '1.26.2'
           cache: true
       - name: Download TinyGo build
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v8
         with:
-          name: windows-amd64-double-zipped-${{ needs.build-windows.outputs.version }}
+          name: tinygo${{ needs.build-windows.outputs.version }}.windows-amd64.zip
           path: build/
-      - name: Unzip TinyGo build
-        shell: bash
-        working-directory: build
-        run: 7z x tinygo*.windows-amd64.zip -r
+        # This build is already unzipped.
       - name: Smoke tests
         shell: bash
         run: make smoketest TINYGO=$(PWD)/build/tinygo/bin/tinygo
@@ -173,21 +164,18 @@ jobs:
           maximum-size: 24GB
           disk-root: "C:"
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: Install Go
         uses: actions/setup-go@v6
         with:
-          go-version: '1.25.5'
+          go-version: '1.26.2'
           cache: true
       - name: Download TinyGo build
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v8
         with:
-          name: windows-amd64-double-zipped-${{ needs.build-windows.outputs.version }}
+          name: tinygo${{ needs.build-windows.outputs.version }}.windows-amd64.zip
           path: build/
-      - name: Unzip TinyGo build
-        shell: bash
-        working-directory: build
-        run: 7z x tinygo*.windows-amd64.zip -r
+        # This build is already unzipped.
       - name: Test stdlib packages
         run: make tinygo-test TINYGO=$(PWD)/build/tinygo/bin/tinygo
 
@@ -202,27 +190,23 @@ jobs:
           maximum-size: 24GB
           disk-root: "C:"
       - uses: MinoruSekine/setup-scoop@v4
-        with:
-          scoop_update: 'false'
       - name: Install Dependencies
         shell: bash
         run: |
-          scoop install binaryen && scoop install wasmtime@29.0.1
+          scoop config use_external_7zip true
+          scoop install binaryen wasmtime@29.0.1
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: Install Go
         uses: actions/setup-go@v6
         with:
-          go-version: '1.25.5'
+          go-version: '1.26.2'
           cache: true
       - name: Download TinyGo build
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v8
         with:
-          name: windows-amd64-double-zipped-${{ needs.build-windows.outputs.version }}
+          name: tinygo${{ needs.build-windows.outputs.version }}.windows-amd64.zip
           path: build/
-      - name: Unzip TinyGo build
-        shell: bash
-        working-directory: build
-        run: 7z x tinygo*.windows-amd64.zip -r
+        # This build is already unzipped.
       - name: Test stdlib packages on wasip1
         run: make tinygo-test-wasip1-fast TINYGO=$(PWD)/build/tinygo/bin/tinygo

CHANGELOG.md

@@ -1,3 +1,160 @@
+0.41.1
+---
+* **machine**
+  - esp32c3: correct pin interrupt setup call that was overlooked from #5320
+* **runtime**
+  - esp32s3: wait for TIMG0 update register to clear before reading timer registers
+* **net**
+  - update net module to a version that is backwards compatible with Go 1.25.x to fix #5332
+
+0.41.0
+---
+* **general**
+  - go.mod, compiler: bump minimum Go version to 1.23
+  - builder: support Go 1.26 now
+  - feat: add inheritable-only field to filter processor-level targets (#5270)
+  - feature: add esp32flash flash method for esp32s3/esp32c3/esp32/esp8266
+  - flashing: introduce flash method 'esp32jtag' for esp32c3/esp32s3 targets
+  - fashing: add "adb" flash method using Android Debug Bridge
+  - main: auto-use best available flashing options on esp32
+  - espflasher: update to espflasher 0.6.0
+* **compiler**
+  - implement method-set based AssignableTo and Implements (#5304)
+  - simplify createObjectLayout
+  - implement copy directly
+  - fix min/max on floats by using intrinsics
+  - add element layout to sliceAppend
+  - add intrinsic for crypto/internal/constanttime.boolToUint8
+  - fix SyscallN handling for Windows on Go 1.26+
+* **core**
+  - reflect: add TypeAssert
+  - reflect: fix TypeAssert for structs
+  - sync: add WaitGroup.Go
+  - os: add UserCacheDir and UserConfigDir
+  - os: implement Lchown function for changing file ownership (#5161)
+  - testing: add b.ReportMetric()
+  - errors: add errors package to passing list
+  - internal/gclayout: use correct lengths
+  - internal/abi: add EscapeNonString, EscapeToResultNonString
+  - internal, runtime: add internal fips bool
+  - internal/itoa: resurrect from Go stdlib
+  - internal/syscall/unix: implement GetRandom for WASI targets
+  - interp: make ptrtoint size mismatch a recoverable error
+  - loader: support "all:" prefix in //go:embed patterns
+  - loader, crypto/internal/entropy: fix 32 MiB RAM overflow on microcontrollers
+  - loader, unicode/utf8: fix hiBits overflow on 16-bit AVR targets
+  - builder: order embedded files deterministically
+  - builder: fix panic in findPackagePath when using -size short
+  - builder: fix SIGSEGV when stripping duplicate function definitions
+  - builder, runtime: fix duplicate symbol error with Go 1.26+ on Windows
+  - builder: use target-specific -march for RISC-V library compilation
+  - transform: modify output format from the -print-allocs flag to match the go coverage tool format
+  - cgo: allow for changes to 'short-enums' flag
+  - wasm: add more stubbed file operations
+* **machine**
+  - esp32c3: implement BlockDevice for esp32c3 flash
+  - esp32c3: clear GPIO STATUS before dispatching pin callbacks
+  - esp32c3: implement USBDevice using interrupts
+  - esp32c3: add Enable stub for QEMU test target
+  - esp32c3: fix interrupt disable handling
+  - esp32c3: clear MCAUSE after handling interrupt
+  - esp32c3: map missing IRAM sections in linker script
+  - esp32c3: fix to use PROVIDE() for WiFi/BLE ROM function addresses to allow blob overrides
+  - esp32c3: add WiFi/BLE ROM linker support
+  - esp32c3: use TIMG0 alarm interrupt for sleepTicks instead of busy-waiting
+  - esp32s3: implement Pin.SetInterrupt for GPIO pin change interrupts
+  - esp32s3: use edge-triggered CPU interrupt for GPIO pin interrupts
+  - esp32s3: add interrupt support (#5244)
+  - esp32s3: switch USB implementation to use interrupts instead of polling
+  - esp32s3: replace inline ISR with full interrupt vector handler
+  - esp32s3: use TIMG0 alarm interrupt for sleepTicks
+  - esp32s3: improve exception handlers, add procPin/procUnpin, and linker wrap flags
+  - esp32s3: fix Xtensa register window spill using recursive call4 in task switching
+  - esp32s3: update linker script and boot assembly for multi-page flash XIP mapping
+  - esp32s3: add flash XIP boot assembly with cache/MMU init
+  - esp32s3: implement SPI (#5169)
+  - esp32s3: implement I2C interface (#5210)
+  - esp32s3: implement RNG based on onboard hardware random number generator
+  - esp32s3,esp32c3: add USB serial support
+  - esp32s3,esp32c3: add txStalled flag to skip USB serial spin when no host
+  - esp32s3,esp32c3: make USB Serial/JTAG writes non-blocking when FIFO is full
+  - esp32c3/esp32s3: refactor ADC implementation to reduce code duplication
+  - esp32s3,esp32c3: add ADC support (#5231)
+  - esp32s3,esp32c3: add PWM support (#5215)
+  - esp32c3/esp32s3: refactoring and corrections for SPI implementation
+  - esp32xx: add WASM simulator support for ESP32-C3/ESP32-S3 targets
+  - esp32: default SPI CS pin to NoPin when unset
+  - esp: fix tinygo_scanCurrentStack to spill register windows
+  - stm32: fix UART interrupt storm caused by uncleared overrun error
+  - stm32: fix PWM problem due to register shifting
+  - stm32: add STM32U585 target definition and runtime
+  - stm32: add STM32U5 GPIO, pin interrupts, and UART support
+  - stm32: add STM32U5 I2C support
+  - stm32: add STM32U5 SPI support
+  - stm32u585: implement ADC
+  - stm32g0b1: add support (#5150)
+  - stm32g0b1: add Watchdog + ADC support (#5158)
+  - stm32l0: add flash support
+  - stm32l0x1,l0x2: TIM: adapt to 32-bit register access
+  - stm32g0: sync with updated stm32 device files
+  - attiny85: add USI-based SPI support (#5181)
+  - attiny85: add PWM support (#5171)
+  - rp: add Close function to UART to allow for removing all system resources/power usage
+  - rp: use blockReset() and unresetBlockWait() helper functions for peripheral reset/unreset
+  - rp2: prevent PWM Period method overflow
+  - rp2: add per-byte timeout budget for I2C (#5189)
+  - feather-m0: export UART0 and pins
+  - usb/cdc: better ring buffer implementation (#5209)
+  - fix: replace ! with ~ for register mask
+  - atmega328p_simulator: add correct build tag for arduino_uno after renaming
+* **net**
+  - update to Go 1.26.2 net package with UDP and JS improvements
+* **runtime**
+  - implement fminimum/fmaximum
+  - make timeoffset atomic
+  - add MemStats.HeapObjects
+  - handle GODEBUG on wasip2 (#5312)
+  - fix Darwin syscall return value truncation and lost arguments
+  - add syscall.runtimeClearenv for Go 1.26
+  - split syscall functions for darwin changes for 1.26
+  - fix: init heap before random number seed on wasm platforms
+* **targets**
+  - add esp32s3-supermini board target
+  - add support for Seeedstudio Xiao-RP2350 board
+  - add Shrike Lite board (#5170)
+  - rename arduino target to arduino-uno
+  - add pins/setup for Arduino UNO Q board QWIIC connector
+  - correct pin mapping for Arduino UNO Q STM32 MCU
+  - add stm32u585 openocd commands for flashing on Arduino UNO Q
+  - correct name/tag use for esp32s3-wroom1 board
+  - modify esp32, esp32s3, esp32c3, & esp8266 targets to use built-in esp32flash
+  - switch rp2040/rp2350 to default to tasks scheduler
+  - change default stack size for esp32c3 and esp32s3 to 8196
+  - swan: rename group build tag stm32l4x5 => stm32l4y5 to avoid clash with stm32 device name
+  - nucleo-f722ze: add build-tag stm32f722
+  - fix: set stm32u5x clock rate to default
+  - create generic targets for esp32 boards
+* **libs**
+  - stm32-svd: update submodule
+  - update tools/gen-device-svd for recent changes to stm32-svd file structure (#5212)
+* **build/test**
+  - build: use Golang 1.26 for all builds
+  - build: actually use the version of llvm we are supposed to be testing by using brew link command
+  - build: let scoop run updates to resolve binaryen install failures on Windows
+  - ci: don't double zip release artifacts
+  - test: increase default timeout from 1 to 2 minutes to prevent spurious CI fails
+  - testdata: fix flaky timers test by draining ticker channel after Stop
+  - testdata: more corpus entries (#5182)
+  - add soypat/lneto to corpus
+  - GNUmakefile: add context and expvar to stdlib tests
+  - GNUmakefile: add encoding/xml to stdlib tests on Linux
+  - main (test): skip mipsle test if the emulator is missing
+  - make: remove machine without board from smoketest
+  - stm32: add Arduino UNO Q to smoketests
+  - flake: bump to nixpkgs 25.11
+  - chore: update all github actions to latest versions
+  - fix: use external 7zip for scoop installs on Windows
+
 0.40.1
 ---
 * **machine**

Dockerfile

@@ -1,5 +1,5 @@
 # tinygo-llvm stage obtains the llvm source for TinyGo
-FROM golang:1.25 AS tinygo-llvm
+FROM golang:1.26 AS tinygo-llvm
 
 RUN apt-get update && \
     apt-get install -y apt-utils make cmake clang-17 ninja-build && \
@@ -33,7 +33,7 @@ RUN cd /tinygo/ && \
 
 # tinygo-compiler copies the compiler build over to a base Go container (without
 # all the build tools etc).
-FROM golang:1.25 AS tinygo-compiler
+FROM golang:1.26 AS tinygo-compiler
 
 # Copy tinygo build.
 COPY --from=tinygo-compiler-build /tinygo/build/release/tinygo /tinygo

GNUmakefile

@@ -289,13 +289,13 @@ WASM_TOOLS_MODULE=go.bytecodealliance.org
 .PHONY: wasi-syscall
 wasi-syscall: wasi-cm
 	rm -rf ./src/internal/wasi/*
-	go run -modfile ./internal/wasm-tools/go.mod $(WASM_TOOLS_MODULE)/cmd/wit-bindgen-go generate --versioned -o ./src/internal -p internal --cm internal/cm ./lib/wasi-cli/wit
+	go run $(WASM_TOOLS_MODULE)/cmd/wit-bindgen-go generate --versioned -o ./src/internal -p internal --cm internal/cm ./lib/wasi-cli/wit
 
 # Copy package cm into src/internal/cm
 .PHONY: wasi-cm
 wasi-cm:
 	rm -rf ./src/internal/cm/*
-	rsync -rv --delete --exclude go.mod --exclude '*_test.go' --exclude '*_json.go' --exclude '*.md' --exclude LICENSE $(shell go list -modfile ./internal/wasm-tools/go.mod -m -f {{.Dir}} $(WASM_TOOLS_MODULE)/cm)/ ./src/internal/cm
+	rsync -rv --delete --exclude go.mod --exclude '*_test.go' --exclude '*_json.go' --exclude '*.md' --exclude LICENSE $(shell go list -m -f {{.Dir}} $(WASM_TOOLS_MODULE)/cm)/ ./src/internal/cm
 
 # Check for Node.js used during WASM tests.
 MIN_NODEJS_VERSION=18
@@ -339,14 +339,17 @@ TEST_PACKAGES_FAST = \
 	embed/internal/embedtest \
 	encoding \
 	encoding/ascii85 \
+	errors \
 	encoding/asn1 \
 	encoding/base32 \
 	encoding/base64 \
 	encoding/csv \
 	encoding/hex \
+	expvar \
 	go/ast \
 	go/format \
 	go/scanner \
+	go/token \
 	go/version \
 	hash \
 	hash/adler32 \
@@ -359,6 +362,7 @@ TEST_PACKAGES_FAST = \
 	math/cmplx \
 	net/http/internal/ascii \
 	net/mail \
+	net/url \
 	os \
 	path \
 	reflect \
@@ -379,6 +383,7 @@ TEST_PACKAGES_FAST = \
 # crypto/des fails on wasi, needs panic()/recover()
 # 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
+# encoding/xml takes a minute on linux and gives a stack overflow on wasi
 # image requires recover(), which is not yet supported on wasi
 # io/ioutil requires os.ReadDir, which is not yet supported on windows or wasi
 # mime: fail on wasi; neds panic()/recover()
@@ -396,11 +401,13 @@ TEST_PACKAGES_FAST = \
 TEST_PACKAGES_LINUX := \
 	archive/zip \
 	compress/flate \
+	context \
 	crypto/aes \
 	crypto/des \
 	crypto/hmac \
 	debug/dwarf \
 	debug/plan9obj \
+	encoding/xml \
 	image \
 	io/ioutil \
 	mime \
@@ -437,6 +444,7 @@ TEST_PACKAGES_NONWASM = \
 	crypto/ecdsa \
 	debug/macho \
 	embed/internal/embedtest \
+	expvar \
 	go/format \
 	os \
 	testing \
@@ -480,7 +488,7 @@ TEST_PACKAGES_HOST := $(TEST_PACKAGES_FAST) $(TEST_PACKAGES_WINDOWS)
 TEST_IOFS := false
 endif
 
-TEST_SKIP_FLAG := -skip='TestExtraMethods|TestParseAndBytesRoundTrip/P256/Generic'
+TEST_SKIP_FLAG := -skip='TestExtraMethods|TestParseAndBytesRoundTrip/P256/Generic|TestAsValidation'
 TEST_ADDITIONAL_FLAGS ?=
 
 # Test known-working standard library packages.
@@ -626,7 +634,7 @@ smoketest: testchdir
 	@$(MD5SUM) test.hex
 	# test simulated boards on play.tinygo.org
 ifneq ($(WASM), 0)
-	GOOS=js GOARCH=wasm $(TINYGO) build -size short -o test.wasm -tags=arduino              examples/blinky1
+	GOOS=js GOARCH=wasm $(TINYGO) build -size short -o test.wasm -tags=arduino_uno          examples/blinky1
 	@$(MD5SUM) test.wasm
 	GOOS=js GOARCH=wasm $(TINYGO) build -size short -o test.wasm -tags=hifive1b             examples/blinky1
 	@$(MD5SUM) test.wasm
@@ -644,6 +652,8 @@ ifneq ($(WASM), 0)
 	@$(MD5SUM) test.wasm
 	GOOS=js GOARCH=wasm $(TINYGO) build -size short -o test.wasm -tags=pico                 examples/blinky1
 	@$(MD5SUM) test.wasm
+	GOOS=js GOARCH=wasm $(TINYGO) build -size short -o test.wasm -tags=xiao_esp32s3         examples/blinky1
+	@$(MD5SUM) test.wasm
 endif
 	# test all targets/boards
 	$(TINYGO) build -size short -o test.hex -target=pca10040-s132v6     examples/blinky1
@@ -814,6 +824,10 @@ endif
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=waveshare-rp2040-tiny examples/echo
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=vicharak_shrike-lite examples/echo
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=xiao-rp2350        examples/blinky1
+	@$(MD5SUM) test.hex
 	# test pwm
 	$(TINYGO) build -size short -o test.hex -target=itsybitsy-m0        examples/pwm
 	@$(MD5SUM) test.hex
@@ -873,18 +887,24 @@ ifneq ($(STM32), 0)
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=stm32l0x1           examples/serial
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=arduino-uno-q       examples/blinky1
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=arduino-uno-q       examples/serial
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=arduino-uno-q       examples/blinkm
+	@$(MD5SUM) test.hex
 endif
 	$(TINYGO) build -size short -o test.hex -target=atmega328pb         examples/blinkm
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=atmega1284p         examples/machinetest
 	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=arduino             examples/blinky1
+	$(TINYGO) build -size short -o test.hex -target=arduino-uno         examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=arduino-leonardo    examples/blinky1
 	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=arduino             examples/pwm
+	$(TINYGO) build -size short -o test.hex -target=arduino-uno         examples/pwm
 	@$(MD5SUM) test.hex
-	$(TINYGO) build -size short -o test.hex -target=arduino -scheduler=tasks  examples/blinky1
+	$(TINYGO) build -size short -o test.hex -target=arduino-uno -scheduler=tasks  examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=arduino-mega1280    examples/blinky1
 	@$(MD5SUM) test.hex
@@ -896,13 +916,25 @@ endif
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=digispark           examples/blinky1
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=digispark           examples/pwm
+	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=digispark           examples/mcp3008
+	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=digispark -gc=leaking examples/blinky1
 	@$(MD5SUM) test.hex
 ifneq ($(XTENSA), 0)
+	$(TINYGO) build -size short -o test.bin -target=esp32-generic       examples/machinetest
+	@$(MD5SUM) test.bin
+	$(TINYGO) build -size short -o test.bin -target=esp32c3-generic     examples/machinetest
+	@$(MD5SUM) test.bin
+	$(TINYGO) build -size short -o test.bin -target=esp32s3-generic     examples/machinetest
+	@$(MD5SUM) test.bin
 	$(TINYGO) build -size short -o test.bin -target=esp32-mini32      	examples/blinky1
 	@$(MD5SUM) test.bin
 	$(TINYGO) build -size short -o test.bin -target=esp32c3-supermini   examples/blinky1
 	@$(MD5SUM) test.bin
+	$(TINYGO) build -size short -o test.bin -target=esp32c3-supermini   examples/blinkm
+	@$(MD5SUM) test.bin
 	$(TINYGO) build -size short -o test.bin -target=nodemcu             examples/blinky1
 	@$(MD5SUM) test.bin
 	$(TINYGO) build -size short -o test.bin -target m5stack-core2       examples/machinetest
@@ -915,9 +947,39 @@ ifneq ($(XTENSA), 0)
 	@$(MD5SUM) test.bin
 	$(TINYGO) build -size short -o test.bin -target mch2022             examples/machinetest
 	@$(MD5SUM) test.bin
+	# xiao-esp32s3
 	$(TINYGO) build -size short -o test.bin -target=xiao-esp32s3   		examples/blinky1
 	@$(MD5SUM) test.bin
+	$(TINYGO) build -size short -o test.bin -target=xiao-esp32s3   		examples/blinkm
+	@$(MD5SUM) test.bin
+	$(TINYGO) build -size short -o test.bin -target=xiao-esp32s3   		examples/mcp3008
+	@$(MD5SUM) test.bin
+	$(TINYGO) build -size short -o test.bin -target=xiao-esp32s3   		examples/pwm
+	@$(MD5SUM) test.bin
+	$(TINYGO) build -size short -o test.bin -target=xiao-esp32s3   		examples/adc
+	@$(MD5SUM) test.bin
+	# esp32s3-supermini
+	$(TINYGO) build -size short -o test.bin -target=esp32s3-supermini	    examples/blinky1
+	@$(MD5SUM) test.bin
+	$(TINYGO) build -size short -o test.bin -target=esp32s3-supermini	    examples/blinkm
+	@$(MD5SUM) test.bin
+	$(TINYGO) build -size short -o test.bin -target=esp32s3-supermini	    examples/mcp3008
+	@$(MD5SUM) test.bin
+	$(TINYGO) build -size short -o test.bin -target=esp32s3-supermini   	examples/adc
+	@$(MD5SUM) test.bin
 endif
+    # esp32c3-supermini
+	$(TINYGO) build -size short -o test.bin -target=esp32c3-supermini	    examples/blinky1
+	@$(MD5SUM) test.bin
+	$(TINYGO) build -size short -o test.bin -target=esp32c3-supermini	    examples/blinkm
+	@$(MD5SUM) test.bin
+	$(TINYGO) build -size short -o test.bin -target=esp32c3-supermini	    examples/mcp3008
+	@$(MD5SUM) test.bin
+	$(TINYGO) build -size short -o test.bin -target=esp32c3-supermini   	examples/pwm
+	@$(MD5SUM) test.bin
+	$(TINYGO) build -size short -o test.bin -target=esp32c3-supermini   	examples/adc
+	@$(MD5SUM) test.bin
+
 	$(TINYGO) build -size short -o test.bin -target=esp-c3-32s-kit      examples/blinky1
 	@$(MD5SUM) test.bin
 	$(TINYGO) build -size short -o test.bin -target=qtpy-esp32c3        examples/machinetest
@@ -930,6 +992,7 @@ endif
 	@$(MD5SUM) test.bin
 	$(TINYGO) build -size short -o test.bin -target=esp32c3-12f         examples/blinky1
 	@$(MD5SUM) test.bin
+
 	$(TINYGO) build -size short -o test.bin -target=makerfabs-esp32c3spi35 examples/machinetest
 	@$(MD5SUM) test.bin
 	$(TINYGO) build -size short -o test.hex -target=hifive1b            examples/blinky1
@@ -1123,7 +1186,7 @@ endif
 
 .PHONY: tools
 tools:
-	cd internal/tools && go generate -tags tools ./
+	go generate -tags tools ./
 
 LINTDIRS=src/os/ src/reflect/
 .PHONY: lint

README.md

@@ -1,11 +1,14 @@
 # TinyGo - Go compiler for small places
 
-[![Linux](https://github.com/tinygo-org/tinygo/actions/workflows/linux.yml/badge.svg?branch=dev)](https://github.com/tinygo-org/tinygo/actions/workflows/linux.yml) [![macOS](https://github.com/tinygo-org/tinygo/actions/workflows/build-macos.yml/badge.svg?branch=dev)](https://github.com/tinygo-org/tinygo/actions/workflows/build-macos.yml) [![Windows](https://github.com/tinygo-org/tinygo/actions/workflows/windows.yml/badge.svg?branch=dev)](https://github.com/tinygo-org/tinygo/actions/workflows/windows.yml) [![Docker](https://github.com/tinygo-org/tinygo/actions/workflows/docker.yml/badge.svg?branch=dev)](https://github.com/tinygo-org/tinygo/actions/workflows/docker.yml) [![Nix](https://github.com/tinygo-org/tinygo/actions/workflows/nix.yml/badge.svg?branch=dev)](https://github.com/tinygo-org/tinygo/actions/workflows/nix.yml) [![CircleCI](https://circleci.com/gh/tinygo-org/tinygo/tree/dev.svg?style=svg)](https://circleci.com/gh/tinygo-org/tinygo/tree/dev)
+[![Linux](https://github.com/tinygo-org/tinygo/actions/workflows/linux.yml/badge.svg?branch=dev)](https://github.com/tinygo-org/tinygo/actions/workflows/linux.yml) [![macOS](https://github.com/tinygo-org/tinygo/actions/workflows/build-macos.yml/badge.svg?branch=dev)](https://github.com/tinygo-org/tinygo/actions/workflows/build-macos.yml) [![Windows](https://github.com/tinygo-org/tinygo/actions/workflows/windows.yml/badge.svg?branch=dev)](https://github.com/tinygo-org/tinygo/actions/workflows/windows.yml) [![Docker](https://github.com/tinygo-org/tinygo/actions/workflows/docker.yml/badge.svg?branch=dev)](https://github.com/tinygo-org/tinygo/actions/workflows/docker.yml) [![Nix](https://github.com/tinygo-org/tinygo/actions/workflows/nix.yml/badge.svg?branch=dev)](https://github.com/tinygo-org/tinygo/actions/workflows/nix.yml)
 
 TinyGo is a Go compiler intended for use in small places such as microcontrollers, WebAssembly (wasm/wasi), and command-line tools.
 
 It reuses libraries used by the [Go language tools](https://golang.org/pkg/go/) alongside [LLVM](http://llvm.org) to provide an alternative way to compile programs written in the Go programming language.
 
+> [!IMPORTANT]
+> You can help TinyGo with a financial contribution using OpenCollective. Please see https://opencollective.com/tinygo for more information. Thank you!
+
 ## Embedded
 
 Here is an example program that blinks the built-in LED when run directly on any supported board with onboard LED:
@@ -31,10 +34,10 @@ func main() {
 }
 ```
 
-The above program can be compiled and run without modification on an Arduino Uno, an Adafruit ItsyBitsy M0, or any of the supported boards that have a built-in LED, just by setting the correct TinyGo compiler target. For example, this compiles and flashes an Arduino Uno:
+The above program can be compiled and run without modification on an [Arduino Uno](https://tinygo.org/docs/reference/microcontrollers/boards/arduino-uno), an [Adafruit Circuit Playground Express](https://tinygo.org/docs/reference/microcontrollers/featured/circuitplay-express), a [Seeed Studio XIAO-ESP32S3](https://tinygo.org/docs/reference/microcontrollers/featured/xiao-esp32s3) or any of the many supported boards that have a built-in LED, just by setting the correct TinyGo compiler target. For example, this compiles and flashes an Arduino Uno:
 
 ```shell
-tinygo flash -target arduino examples/blinky1
+tinygo flash -target arduino-uno examples/blinky1
 ```
 
 ## WebAssembly
@@ -63,7 +66,7 @@ tinygo build -buildmode=c-shared -o add.wasm -target=wasip1 add.go
 You can also use the same syntax as Go 1.24+:
 
 ```shell
-GOARCH=wasip1 GOOS=wasm tinygo build -buildmode=c-shared -o add.wasm add.go
+GOOS=wasip1 GOARCH=wasm tinygo build -buildmode=c-shared -o add.wasm add.go
 ```
 
 ## Installation
@@ -74,7 +77,7 @@ See the [getting started instructions](https://tinygo.org/getting-started/) for
 
 ### Embedded
 
-You can compile TinyGo programs for over 94 different microcontroller boards.
+You can compile TinyGo programs for over 150 different microcontroller boards.
 
 For more information, please see https://tinygo.org/docs/reference/microcontrollers/
 
@@ -139,7 +142,7 @@ Non-goals:
 
 ## Why this project exists
 
-> We never expected Go to be an embedded language and so its got serious problems...
+> We never expected Go to be an embedded language, and so it’s got serious problems...
 
 -- Rob Pike, [GopherCon 2014 Opening Keynote](https://www.youtube.com/watch?v=VoS7DsT1rdM&feature=youtu.be&t=2799)
 

builder/build.go

@@ -19,6 +19,7 @@ import (
 	"os/exec"
 	"path/filepath"
 	"runtime"
+	"slices"
 	"sort"
 	"strconv"
 	"strings"
@@ -254,6 +255,18 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 		result.PackagePathMap[pkg.OriginalDir()] = pkg.Pkg.Path()
 	}
 
+	// Strip default initializers for -X globals from the type info before
+	// building SSA. This prevents go/ssa from emitting init stores for them,
+	// so that makeGlobalsModule can supply the correct values at final link
+	// time without any runtime init overwriting them. The -X values themselves
+	// are kept out of the per-package build cache; only the variable names
+	// appear in the cache key.
+	for _, pkg := range lprogram.Sorted() {
+		for name := range globalValues[pkg.Pkg.Path()] {
+			pkg.StripVarInitializer(name)
+		}
+	}
+
 	// Create the *ssa.Program. This does not yet build the entire SSA of the
 	// program so it's pretty fast and doesn't need to be parallelized.
 	program := lprogram.LoadSSA()
@@ -281,9 +294,13 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 				allFiles[file.Name] = append(allFiles[file.Name], file)
 			}
 		}
-		for name, files := range allFiles {
-			name := name
-			files := files
+		// Sort embedded files by name to maintain output determinism.
+		embedNames := make([]string, 0, len(allFiles))
+		for _, files := range allFiles {
+			embedNames = append(embedNames, files[0].Name)
+		}
+		slices.Sort(embedNames)
+		for _, name := range embedNames {
 			job := &compileJob{
 				description: "make object file for " + name,
 				run: func(job *compileJob) error {
@@ -298,7 +315,7 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 					sum := sha256.Sum256(data)
 					hexSum := hex.EncodeToString(sum[:16])
 
-					for _, file := range files {
+					for _, file := range allFiles[name] {
 						file.Size = uint64(len(data))
 						file.Hash = hexSum
 						if file.NeedsData {
@@ -472,7 +489,7 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 				if pkgInit.IsNil() {
 					panic("init not found for " + pkg.Pkg.Path())
 				}
-				err := interp.RunFunc(pkgInit, config.Options.InterpTimeout, config.DumpSSA())
+				err := interp.RunFunc(pkgInit, config.Options.InterpTimeout, config.Options.InterpMaxLoopIterations, config.DumpSSA())
 				if err != nil {
 					return err
 				}
@@ -541,6 +558,23 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 				if err != nil {
 					return fmt.Errorf("failed to load bitcode file: %w", err)
 				}
+				// Resolve duplicate function definitions before linking.
+				// This can happen when a newer Go version adds a function
+				// body in a standard library package that was previously
+				// just a declaration provided by //go:linkname from the
+				// runtime. In that case, keep the existing (runtime)
+				// definition by weakening the new one's linkage so the
+				// LLVM linker discards it in favor of the existing one.
+				for fn := pkgMod.FirstFunction(); !fn.IsNil(); fn = llvm.NextFunction(fn) {
+					if fn.IsDeclaration() {
+						continue
+					}
+					existing := mod.NamedFunction(fn.Name())
+					if existing.IsNil() || existing.IsDeclaration() {
+						continue
+					}
+					fn.SetLinkage(llvm.LinkOnceODRLinkage)
+				}
 				err = llvm.LinkModules(mod, pkgMod)
 				if err != nil {
 					return fmt.Errorf("failed to link module: %w", err)
@@ -1174,7 +1208,7 @@ func createEmbedObjectFile(data, hexSum, sourceFile, sourceDir, tmpdir string, c
 // 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.Options.InterpTimeout, config.DumpSSA())
+	err := interp.Run(mod, config.Options.InterpTimeout, config.Options.InterpMaxLoopIterations, config.DumpSSA())
 	if err != nil {
 		return err
 	}

builder/cc1as.h

@@ -107,7 +107,7 @@ struct AssemblerInvocation {
   EmitDwarfUnwindType EmitDwarfUnwind;
 
   // Whether to emit compact-unwind for non-canonical entries.
-  // Note: maybe overriden by other constraints.
+  // Note: maybe overridden by other constraints.
   LLVM_PREFERRED_TYPE(bool)
   unsigned EmitCompactUnwindNonCanonical : 1;
 

builder/config.go

@@ -26,7 +26,7 @@ func NewConfig(options *compileopts.Options) (*compileopts.Config, error) {
 
 	// Version range supported by TinyGo.
 	const minorMin = 19
-	const minorMax = 25
+	const minorMax = 26
 
 	// Check that we support this Go toolchain version.
 	gorootMajor, gorootMinor, err := goenv.GetGorootVersion()

builder/library.go

@@ -167,9 +167,9 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 		// double.
 		args = append(args, "-mdouble=64")
 	case "riscv32":
-		args = append(args, "-march=rv32imac", "-fforce-enable-int128")
+		args = append(args, "-march="+riscvMarch(config, "rv32imac"), "-fforce-enable-int128")
 	case "riscv64":
-		args = append(args, "-march=rv64gc")
+		args = append(args, "-march="+riscvMarch(config, "rv64gc"))
 	case "mips":
 		args = append(args, "-fno-pic")
 	}
@@ -298,3 +298,17 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 		once.Do(unlock)
 	}, nil
 }
+
+// riscvMarch returns the -march value for RISC-V library compilation.
+// It extracts the value from the target's cflags if present, otherwise
+// falls back to the provided default. This ensures libraries are compiled
+// with the correct ISA extensions for each target (e.g. rv32imc for
+// ESP32-C3 which lacks the atomic extension).
+func riscvMarch(config *compileopts.Config, defaultMarch string) string {
+	for _, flag := range config.Target.CFlags {
+		if strings.HasPrefix(flag, "-march=") {
+			return flag[len("-march="):]
+		}
+	}
+	return defaultMarch
+}

builder/sizes.go

@@ -954,7 +954,11 @@ func findPackagePath(path string, packagePathMap map[string]string) (packagePath
 			libPath := strings.TrimPrefix(path, filepath.Join(goenv.Get("TINYGOROOT"), "lib")+string(os.PathSeparator))
 			parts := strings.SplitN(libPath, string(os.PathSeparator), 2)
 			packagePath = "C " + parts[0]
-			filename = parts[1]
+			if len(parts) > 1 {
+				filename = parts[1]
+			} else {
+				filename = parts[0]
+			}
 		} else if prefix := filepath.Join(goenv.Get("TINYGOROOT"), "llvm-project", "compiler-rt"); strings.HasPrefix(path, prefix) {
 			packagePath = "C compiler-rt"
 			filename = strings.TrimPrefix(path, prefix+string(os.PathSeparator))

builder/sizes_test.go

@@ -42,9 +42,9 @@ func TestBinarySize(t *testing.T) {
 	// This is a small number of very diverse targets that we want to test.
 	tests := []sizeTest{
 		// microcontrollers
-		{"hifive1b", "examples/echo", 3668, 280, 0, 2244},
+		{"hifive1b", "examples/echo", 3680, 280, 0, 2252},
 		{"microbit", "examples/serial", 2694, 342, 8, 2248},
-		{"wioterminal", "examples/pininterrupt", 6837, 1491, 120, 6888},
+		{"wioterminal", "examples/pininterrupt", 7074, 1510, 120, 7248},
 
 		// TODO: also check wasm. Right now this is difficult, because
 		// wasm binaries are run through wasm-opt and therefore the

builder/tools-builtin.go

@@ -28,7 +28,7 @@ func RunTool(tool string, args ...string) error {
 	var cflag *C.char
 	buf := C.calloc(C.size_t(len(args)), C.size_t(unsafe.Sizeof(cflag)))
 	defer C.free(buf)
-	cflags := (*[1 << 10]*C.char)(unsafe.Pointer(buf))[:len(args):len(args)]
+	cflags := unsafe.Slice((**C.char)(buf), len(args))
 	for i, flag := range args {
 		cflag := C.CString(flag)
 		cflags[i] = cflag

builder/tools.go

@@ -122,12 +122,16 @@ func parseLLDErrors(text string) error {
 					parsedError = true
 					line, _ := strconv.Atoi(matches[3])
 					// TODO: detect common mistakes like -gc=none?
+					msg := "linker could not find symbol " + symbolName
+					if symbolName == "runtime.alloc_noheap" {
+						msg = "object allocated on the heap in //go:noheap function"
+					}
 					linkErrors = append(linkErrors, scanner.Error{
 						Pos: token.Position{
 							Filename: matches[2],
 							Line:     line,
 						},
-						Msg: "linker could not find symbol " + symbolName,
+						Msg: msg,
 					})
 				}
 			}

cgo/libclang.go

@@ -130,7 +130,7 @@ func (f *cgoFile) readNames(fragment string, cflags []string, filename string, c
 	// convert Go slice of strings to C array of strings.
 	cmdargsC := C.malloc(C.size_t(len(cflags)) * C.size_t(unsafe.Sizeof(uintptr(0))))
 	defer C.free(cmdargsC)
-	cmdargs := (*[1 << 16]*C.char)(cmdargsC)
+	cmdargs := unsafe.Slice((**C.char)(cmdargsC), len(cflags))
 	for i, cflag := range cflags {
 		s := C.CString(cflag)
 		cmdargs[i] = s
@@ -190,7 +190,7 @@ func (f *cgoFile) readNames(fragment string, cflags []string, filename string, c
 			// Sanity check. This should (hopefully) never trigger.
 			panic("libclang: file contents was not loaded")
 		}
-		data := (*[1 << 24]byte)(unsafe.Pointer(rawData))[:size]
+		data := unsafe.Slice((*byte)(unsafe.Pointer(rawData)), size)
 
 		// Hash the contents if it isn't hashed yet.
 		if _, ok := f.visitedFiles[path]; !ok {
@@ -624,7 +624,7 @@ func (p *cgoPackage) getClangLocationPosition(location C.CXSourceLocation, tu C.
 		// now by reading the file from libclang.
 		var size C.size_t
 		sourcePtr := C.clang_getFileContents(tu, file, &size)
-		source := ((*[1 << 28]byte)(unsafe.Pointer(sourcePtr)))[:size:size]
+		source := unsafe.Slice((*byte)(unsafe.Pointer(sourcePtr)), size)
 		lines := []int{0}
 		for i := 0; i < len(source)-1; i++ {
 			if source[i] == '\n' {

cgo/libclang_config_llvm19.go

@@ -3,7 +3,7 @@
 package cgo
 
 /*
-#cgo linux        CFLAGS:  -I/usr/include/llvm-19 -I/usr/include/llvm-c-19 -I/usr/lib/llvm-19/include
+#cgo linux        CFLAGS:  -I/usr/include/llvm-19 -I/usr/include/llvm-c-19 -I/usr/lib/llvm-19/include -I/usr/lib64/llvm19/include
 #cgo darwin,amd64 CFLAGS:  -I/usr/local/opt/llvm@19/include
 #cgo darwin,arm64 CFLAGS:  -I/opt/homebrew/opt/llvm@19/include
 #cgo freebsd      CFLAGS:  -I/usr/local/llvm19/include

cgo/libclang_config_llvm20.go

@@ -3,7 +3,7 @@
 package cgo
 
 /*
-#cgo linux        CFLAGS:  -I/usr/include/llvm-20 -I/usr/include/llvm-c-20 -I/usr/lib/llvm-20/include
+#cgo linux        CFLAGS:  -I/usr/include/llvm-20 -I/usr/include/llvm-c-20 -I/usr/lib/llvm-20/include -I/usr/lib64/llvm20/include
 #cgo darwin,amd64 CFLAGS:  -I/usr/local/opt/llvm@20/include
 #cgo darwin,arm64 CFLAGS:  -I/opt/homebrew/opt/llvm@20/include
 #cgo freebsd      CFLAGS:  -I/usr/local/llvm20/include

cgo/security.go

@@ -78,6 +78,7 @@ var validCompilerFlags = []*regexp.Regexp{
 	re(`-f(no-)?(pic|PIC|pie|PIE)`),
 	re(`-f(no-)?plt`),
 	re(`-f(no-)?rtti`),
+	re(`-f(no-)?short-enums`),
 	re(`-f(no-)?split-stack`),
 	re(`-f(no-)?stack-(.+)`),
 	re(`-f(no-)?strict-aliasing`),

compileopts/config.go

@@ -536,7 +536,7 @@ func (c *Config) Programmer() (method, openocdInterface string) {
 	case "":
 		// No configuration supplied.
 		return c.Target.FlashMethod, c.Target.OpenOCDInterface
-	case "openocd", "msd", "command":
+	case "openocd", "msd", "command", "adb":
 		// The -programmer flag only specifies the flash method.
 		return c.Options.Programmer, c.Target.OpenOCDInterface
 	case "bmp":

compileopts/options.go

@@ -21,45 +21,46 @@ var (
 // usually passed from the command line, but can also be passed in environment
 // variables for example.
 type Options struct {
-	GOOS            string // environment variable
-	GOARCH          string // environment variable
-	GOARM           string // environment variable (only used with GOARCH=arm)
-	GOMIPS          string // environment variable (only used with GOARCH=mips and GOARCH=mipsle)
-	Directory       string // working dir, leave it unset to use the current working dir
-	Target          string
-	BuildMode       string // -buildmode flag
-	Opt             string
-	GC              string
-	PanicStrategy   string
-	Scheduler       string
-	StackSize       uint64 // goroutine stack size (if none could be automatically determined)
-	Serial          string
-	Work            bool // -work flag to print temporary build directory
-	InterpTimeout   time.Duration
-	PrintIR         bool
-	DumpSSA         bool
-	VerifyIR        bool
-	SkipDWARF       bool
-	PrintCommands   func(cmd string, args ...string) `json:"-"`
-	Semaphore       chan struct{}                    `json:"-"` // -p flag controls cap
-	Debug           bool
-	Nobounds        bool
-	PrintSizes      string
-	PrintAllocs     *regexp.Regexp // regexp string
-	PrintStacks     bool
-	Tags            []string
-	GlobalValues    map[string]map[string]string // map[pkgpath]map[varname]value
-	TestConfig      TestConfig
-	Programmer      string
-	OpenOCDCommands []string
-	LLVMFeatures    string
-	Monitor         bool
-	BaudRate        int
-	Timeout         time.Duration
-	WITPackage      string // pass through to wasm-tools component embed invocation
-	WITWorld        string // pass through to wasm-tools component embed -w option
-	ExtLDFlags      []string
-	GoCompatibility bool // enable to check for Go version compatibility
+	GOOS                    string // environment variable
+	GOARCH                  string // environment variable
+	GOARM                   string // environment variable (only used with GOARCH=arm)
+	GOMIPS                  string // environment variable (only used with GOARCH=mips and GOARCH=mipsle)
+	Directory               string // working dir, leave it unset to use the current working dir
+	Target                  string
+	BuildMode               string // -buildmode flag
+	Opt                     string
+	GC                      string
+	PanicStrategy           string
+	Scheduler               string
+	StackSize               uint64 // goroutine stack size (if none could be automatically determined)
+	Serial                  string
+	Work                    bool // -work flag to print temporary build directory
+	InterpTimeout           time.Duration
+	InterpMaxLoopIterations int
+	PrintIR                 bool
+	DumpSSA                 bool
+	VerifyIR                bool
+	SkipDWARF               bool
+	PrintCommands           func(cmd string, args ...string) `json:"-"`
+	Semaphore               chan struct{}                    `json:"-"` // -p flag controls cap
+	Debug                   bool
+	Nobounds                bool
+	PrintSizes              string
+	PrintAllocs             *regexp.Regexp // regexp string
+	PrintStacks             bool
+	Tags                    []string
+	GlobalValues            map[string]map[string]string // map[pkgpath]map[varname]value
+	TestConfig              TestConfig
+	Programmer              string
+	OpenOCDCommands         []string
+	LLVMFeatures            string
+	Monitor                 bool
+	BaudRate                int
+	Timeout                 time.Duration
+	WITPackage              string // pass through to wasm-tools component embed invocation
+	WITWorld                string // pass through to wasm-tools component embed -w option
+	ExtLDFlags              []string
+	GoCompatibility         bool // enable to check for Go version compatibility
 }
 
 // Verify performs a validation on the given options, raising an error if options are not valid.

compileopts/target.go

@@ -24,6 +24,7 @@ import (
 // https://github.com/shepmaster/rust-arduino-blink-led-no-core-with-cargo/blob/master/blink/arduino.json
 type TargetSpec struct {
 	Inherits         []string `json:"inherits,omitempty"`
+	InheritableOnly  bool     `json:"inheritable-only"` // this target is only meant to be inherited from, not used directly
 	Triple           string   `json:"llvm-target,omitempty"`
 	CPU              string   `json:"cpu,omitempty"`
 	ABI              string   `json:"target-abi,omitempty"` // roughly equivalent to -mabi= flag
@@ -63,6 +64,9 @@ type TargetSpec struct {
 	OpenOCDCommands  []string `json:"openocd-commands,omitempty"`
 	OpenOCDVerify    *bool    `json:"openocd-verify,omitempty"` // enable verify when flashing with openocd
 	JLinkDevice      string   `json:"jlink-device,omitempty"`
+	ADBPreCommands   []string `json:"adb-pre-commands,omitempty"`
+	ADBPushRemote    string   `json:"adb-push-remote,omitempty"`
+	ADBPostCommands  []string `json:"adb-post-commands,omitempty"`
 	CodeModel        string   `json:"code-model,omitempty"`
 	RelocationModel  string   `json:"relocation-model,omitempty"`
 	WITPackage       string   `json:"wit-package,omitempty"`
@@ -148,6 +152,11 @@ func (spec *TargetSpec) loadFromGivenStr(str string) error {
 
 // resolveInherits loads inherited targets, recursively.
 func (spec *TargetSpec) resolveInherits() error {
+	// Save InheritableOnly before resolving, since it must not propagate
+	// from parent to child (a board target should not become inheritable-only
+	// just because its parent processor target is).
+	inheritableOnly := spec.InheritableOnly
+
 	// First create a new spec with all the inherited properties.
 	newSpec := &TargetSpec{}
 	for _, name := range spec.Inherits {
@@ -173,6 +182,9 @@ func (spec *TargetSpec) resolveInherits() error {
 	}
 	*spec = *newSpec
 
+	// Restore InheritableOnly from the original spec, not from parents.
+	spec.InheritableOnly = inheritableOnly
+
 	return nil
 }
 
@@ -239,10 +251,17 @@ func GetTargetSpecs() (map[string]*TargetSpec, error) {
 			continue
 		}
 		path := filepath.Join(dir, entry.Name())
+
 		spec, err := LoadTarget(&Options{Target: path})
 		if err != nil {
 			return nil, fmt.Errorf("could not list target: %w", err)
 		}
+
+		if spec.InheritableOnly {
+			// Skip targets that are only meant to be inherited from, not used directly.
+			continue
+		}
+
 		if spec.FlashMethod == "" && spec.FlashCommand == "" && spec.Emulator == "" {
 			// This doesn't look like a regular target file, but rather like
 			// a parent target (such as targets/cortex-m.json).

compileopts/target_test.go

@@ -23,6 +23,37 @@ func TestLoadTarget(t *testing.T) {
 	}
 }
 
+func TestGetTargetSpecs_InheritableOnlyTargetsExcluded(t *testing.T) {
+	specs, err := GetTargetSpecs()
+	if err != nil {
+		t.Fatal("GetTargetSpecs failed:", err)
+	}
+
+	// Inheritable-only processor-level targets should not appear in the listing.
+	inheritableOnlyTargets := []string{"esp32", "esp32c3", "esp32s3", "esp8266", "rp2040", "rp2350", "rp2350b"}
+	for _, name := range inheritableOnlyTargets {
+		if _, ok := specs[name]; ok {
+			t.Errorf("inheritable-only target %q should not appear in GetTargetSpecs", name)
+		}
+	}
+
+	// Board targets that inherit from inheritable-only targets should still appear.
+	boardTargets := []string{"esp32-coreboard-v2", "pico"}
+	for _, name := range boardTargets {
+		if _, ok := specs[name]; !ok {
+			t.Errorf("board target %q should appear in GetTargetSpecs", name)
+		}
+	}
+}
+
+func TestLoadTarget_InheritableOnlyTargetStillLoadable(t *testing.T) {
+	// Inheritable-only targets should still be loadable directly (for building).
+	_, err := LoadTarget(&Options{Target: "esp32"})
+	if err != nil {
+		t.Errorf("LoadTarget should still load inheritable-only target esp32: %v", err)
+	}
+}
+
 func TestOverrideProperties(t *testing.T) {
 	baseAutoStackSize := true
 	base := &TargetSpec{

compiler/compiler.go

@@ -192,6 +192,16 @@ func newBuilder(c *compilerContext, irbuilder llvm.Builder, f *ssa.Function) *bu
 	}
 }
 
+// Return the runtime.alloc function variant.
+// This is normally just "alloc", but is "alloc_noheap" if the //go:noheap
+// pragma is used.
+func (b *builder) allocFunc() string {
+	if b.info.noheap {
+		return "alloc_noheap"
+	}
+	return "alloc"
+}
+
 type blockInfo struct {
 	// entry is the LLVM basic block corresponding to the start of this *ssa.Block.
 	entry llvm.BasicBlock
@@ -314,9 +324,6 @@ func CompilePackage(moduleName string, pkg *loader.Package, ssaPkg *ssa.Package,
 	// Load comments such as //go:extern on globals.
 	c.loadASTComments(pkg)
 
-	// Predeclare the runtime.alloc function, which is used by the wordpack
-	// functionality.
-	c.getFunction(c.program.ImportedPackage("runtime").Members["alloc"].(*ssa.Function))
 	if c.NeedsStackObjects {
 		// Predeclare trackPointer, which is used everywhere we use runtime.alloc.
 		c.getFunction(c.program.ImportedPackage("runtime").Members["trackPointer"].(*ssa.Function))
@@ -873,6 +880,10 @@ func (c *compilerContext) createPackage(irbuilder llvm.Builder, pkg *ssa.Package
 				// with a LLVM intrinsic.
 				continue
 			}
+			if ok := b.defineCryptoIntrinsic(); ok {
+				// Body of this function was replaced
+				continue
+			}
 			if member.Blocks == nil {
 				// Try to define this as an intrinsic function.
 				b.defineIntrinsicFunction()
@@ -1976,10 +1987,14 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 			return b.emitSV64Call(instr.Args, getPos(instr))
 		case strings.HasPrefix(name, "(device/riscv.CSR)."):
 			return b.emitCSROperation(instr)
-		case strings.HasPrefix(name, "syscall.Syscall") || strings.HasPrefix(name, "syscall.RawSyscall") || strings.HasPrefix(name, "golang.org/x/sys/unix.Syscall") || strings.HasPrefix(name, "golang.org/x/sys/unix.RawSyscall"):
+		case (strings.HasPrefix(name, "syscall.Syscall") || strings.HasPrefix(name, "syscall.RawSyscall") || strings.HasPrefix(name, "golang.org/x/sys/unix.Syscall") || strings.HasPrefix(name, "golang.org/x/sys/unix.RawSyscall")) && name != "syscall.SyscallN":
 			if b.GOOS != "darwin" {
 				return b.createSyscall(instr)
 			}
+		case name == "syscall.syscalln":
+			if b.GOOS == "windows" {
+				return b.createSyscalln(instr)
+			}
 		case strings.HasPrefix(name, "syscall.rawSyscallNoError") || strings.HasPrefix(name, "golang.org/x/sys/unix.RawSyscallNoError"):
 			return b.createRawSyscallNoError(instr)
 		case name == "runtime.supportsRecover":
@@ -2168,7 +2183,7 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 			}
 			sizeValue := llvm.ConstInt(b.uintptrType, size, false)
 			layoutValue := b.createObjectLayout(typ, expr.Pos())
-			buf := b.createRuntimeCall("alloc", []llvm.Value{sizeValue, layoutValue}, expr.Comment)
+			buf := b.createRuntimeCall(b.allocFunc(), []llvm.Value{sizeValue, layoutValue}, expr.Comment)
 			align := b.targetData.ABITypeAlignment(typ)
 			buf.AddCallSiteAttribute(0, b.ctx.CreateEnumAttribute(llvm.AttributeKindID("align"), uint64(align)))
 			return buf, nil
@@ -2400,7 +2415,7 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 		}
 		sliceSize := b.CreateBinOp(llvm.Mul, elemSizeValue, sliceCapCast, "makeslice.cap")
 		layoutValue := b.createObjectLayout(llvmElemType, expr.Pos())
-		slicePtr := b.createRuntimeCall("alloc", []llvm.Value{sliceSize, layoutValue}, "makeslice.buf")
+		slicePtr := b.createRuntimeCall(b.allocFunc(), []llvm.Value{sliceSize, layoutValue}, "makeslice.buf")
 		slicePtr.AddCallSiteAttribute(0, b.ctx.CreateEnumAttribute(llvm.AttributeKindID("align"), uint64(elemAlign)))
 
 		// Extend or truncate if necessary. This is safe as we've already done

compiler/compiler_test.go

@@ -50,6 +50,7 @@ func TestCompiler(t *testing.T) {
 		{"channel.go", "", ""},
 		{"gc.go", "", ""},
 		{"zeromap.go", "", ""},
+		{"generics.go", "", ""},
 	}
 	if goMinor >= 20 {
 		tests = append(tests, testCase{"go1.20.go", "", ""})

compiler/defer.go

@@ -488,7 +488,7 @@ func (b *builder) createDefer(instr *ssa.Defer) {
 		size := b.targetData.TypeAllocSize(deferredCallType)
 		sizeValue := llvm.ConstInt(b.uintptrType, size, false)
 		nilPtr := llvm.ConstNull(b.dataPtrType)
-		alloca = b.createRuntimeCall("alloc", []llvm.Value{sizeValue, nilPtr}, "defer.alloc.call")
+		alloca = b.createRuntimeCall(b.allocFunc(), []llvm.Value{sizeValue, nilPtr}, "defer.alloc.call")
 	}
 	if b.NeedsStackObjects {
 		b.trackPointer(alloca)

compiler/gc.go

@@ -99,6 +99,9 @@ func typeHasPointers(t llvm.Type) bool {
 		}
 		return false
 	case llvm.ArrayTypeKind:
+		if t.ArrayLength() == 0 {
+			return false
+		}
 		if typeHasPointers(t.ElementType()) {
 			return true
 		}

compiler/interface.go

@@ -10,6 +10,7 @@ import (
 	"fmt"
 	"go/token"
 	"go/types"
+	"sort"
 	"strconv"
 	"strings"
 
@@ -17,6 +18,12 @@ import (
 	"tinygo.org/x/go-llvm"
 )
 
+// numMethodHasMethodSet is a flag in bit 15 of the numMethod field (uint16) in
+// Named, Pointer, and Struct type descriptors. When set, an inline method set
+// is present in the type descriptor. Must match the constant in
+// src/internal/reflectlite/type.go.
+const numMethodHasMethodSet = 0x8000
+
 // Type kinds for basic types.
 // They must match the constants for the Kind type in src/reflect/type.go.
 var basicTypes = [...]uint8{
@@ -183,6 +190,16 @@ func (c *compilerContext) getTypeCode(typ types.Type) llvm.Value {
 		typeFieldTypes := []*types.Var{
 			types.NewVar(token.NoPos, nil, "kind", types.Typ[types.Int8]),
 		}
+		// Compute the method set value for types that support methods.
+		var methods []*types.Func
+		for i := 0; i < ms.Len(); i++ {
+			methods = append(methods, ms.At(i).Obj().(*types.Func))
+		}
+		methodSetType := types.NewStruct([]*types.Var{
+			types.NewVar(token.NoPos, nil, "length", types.Typ[types.Uintptr]),
+			types.NewVar(token.NoPos, nil, "methods", types.NewArray(types.Typ[types.UnsafePointer], int64(len(methods)))),
+		}, nil)
+		methodSetValue := c.getMethodSetValue(methods)
 		switch typ := typ.(type) {
 		case *types.Basic:
 			typeFieldTypes = append(typeFieldTypes,
@@ -199,6 +216,13 @@ func (c *compilerContext) getTypeCode(typ types.Type) llvm.Value {
 				types.NewVar(token.NoPos, nil, "ptrTo", types.Typ[types.UnsafePointer]),
 				types.NewVar(token.NoPos, nil, "underlying", types.Typ[types.UnsafePointer]),
 				types.NewVar(token.NoPos, nil, "pkgpath", types.Typ[types.UnsafePointer]),
+			)
+			if len(methods) > 0 {
+				typeFieldTypes = append(typeFieldTypes,
+					types.NewVar(token.NoPos, nil, "methods", methodSetType),
+				)
+			}
+			typeFieldTypes = append(typeFieldTypes,
 				types.NewVar(token.NoPos, nil, "name", types.NewArray(types.Typ[types.Int8], int64(len(pkgname)+1+len(name)+1))),
 			)
 		case *types.Chan:
@@ -218,6 +242,11 @@ func (c *compilerContext) getTypeCode(typ types.Type) llvm.Value {
 				types.NewVar(token.NoPos, nil, "numMethods", types.Typ[types.Uint16]),
 				types.NewVar(token.NoPos, nil, "elementType", types.Typ[types.UnsafePointer]),
 			)
+			if len(methods) > 0 {
+				typeFieldTypes = append(typeFieldTypes,
+					types.NewVar(token.NoPos, nil, "methods", methodSetType),
+				)
+			}
 		case *types.Array:
 			typeFieldTypes = append(typeFieldTypes,
 				types.NewVar(token.NoPos, nil, "numMethods", types.Typ[types.Uint16]),
@@ -242,11 +271,16 @@ func (c *compilerContext) getTypeCode(typ types.Type) llvm.Value {
 				types.NewVar(token.NoPos, nil, "numFields", types.Typ[types.Uint16]),
 				types.NewVar(token.NoPos, nil, "fields", types.NewArray(c.getRuntimeType("structField"), int64(typ.NumFields()))),
 			)
+			if len(methods) > 0 {
+				typeFieldTypes = append(typeFieldTypes,
+					types.NewVar(token.NoPos, nil, "methods", methodSetType),
+				)
+			}
 		case *types.Interface:
 			typeFieldTypes = append(typeFieldTypes,
 				types.NewVar(token.NoPos, nil, "ptrTo", types.Typ[types.UnsafePointer]),
+				types.NewVar(token.NoPos, nil, "methods", methodSetType),
 			)
-			// TODO: methods
 		case *types.Signature:
 			typeFieldTypes = append(typeFieldTypes,
 				types.NewVar(token.NoPos, nil, "ptrTo", types.Typ[types.UnsafePointer]),
@@ -292,14 +326,24 @@ func (c *compilerContext) getTypeCode(typ types.Type) llvm.Value {
 				pkgname = pkg.Name()
 			}
 			pkgPathPtr := c.pkgPathPtr(pkgpath)
-			typeFields = []llvm.Value{
-				llvm.ConstInt(c.ctx.Int16Type(), uint64(numMethods), false), // numMethods
-				c.getTypeCode(types.NewPointer(typ)),                        // ptrTo
-				c.getTypeCode(typ.Underlying()),                             // underlying
-				pkgPathPtr,                                                  // pkgpath pointer
-				c.ctx.ConstString(pkgname+"."+name+"\x00", false),           // name
+			namedNumMethods := uint64(numMethods)
+			if namedNumMethods&numMethodHasMethodSet != 0 {
+				panic("numMethods overflow: too many exported methods on named type " + name)
 			}
-			metabyte |= 1 << 5 // "named" flag
+			if len(methods) > 0 {
+				namedNumMethods |= numMethodHasMethodSet
+			}
+			typeFields = []llvm.Value{
+				llvm.ConstInt(c.ctx.Int16Type(), namedNumMethods, false), // numMethods
+				c.getTypeCode(types.NewPointer(typ)),                     // ptrTo
+				c.getTypeCode(typ.Underlying()),                          // underlying
+				pkgPathPtr,                                               // pkgpath pointer
+			}
+			if len(methods) > 0 {
+				typeFields = append(typeFields, methodSetValue) // methods
+			}
+			typeFields = append(typeFields, c.ctx.ConstString(pkgname+"."+name+"\x00", false)) // name
+			metabyte |= 1 << 5                                                                 // "named" flag
 		case *types.Chan:
 			var dir reflectChanDir
 			switch typ.Dir() {
@@ -323,10 +367,20 @@ func (c *compilerContext) getTypeCode(typ types.Type) llvm.Value {
 				c.getTypeCode(typ.Elem()),                  // elementType
 			}
 		case *types.Pointer:
+			ptrNumMethods := uint64(numMethods)
+			if ptrNumMethods&numMethodHasMethodSet != 0 {
+				panic("numMethods overflow: too many exported methods on pointer type")
+			}
+			if len(methods) > 0 {
+				ptrNumMethods |= numMethodHasMethodSet
+			}
 			typeFields = []llvm.Value{
-				llvm.ConstInt(c.ctx.Int16Type(), uint64(numMethods), false), // numMethods
+				llvm.ConstInt(c.ctx.Int16Type(), ptrNumMethods, false), // numMethods
 				c.getTypeCode(typ.Elem()),
 			}
+			if len(methods) > 0 {
+				typeFields = append(typeFields, methodSetValue)
+			}
 		case *types.Array:
 			typeFields = []llvm.Value{
 				llvm.ConstInt(c.ctx.Int16Type(), 0, false),             // numMethods
@@ -353,9 +407,16 @@ func (c *compilerContext) getTypeCode(typ types.Type) llvm.Value {
 
 			llvmStructType := c.getLLVMType(typ)
 			size := c.targetData.TypeStoreSize(llvmStructType)
+			structNumMethods := uint64(numMethods)
+			if structNumMethods&numMethodHasMethodSet != 0 {
+				panic("numMethods overflow: too many exported methods on struct type")
+			}
+			if len(methods) > 0 {
+				structNumMethods |= numMethodHasMethodSet
+			}
 			typeFields = []llvm.Value{
-				llvm.ConstInt(c.ctx.Int16Type(), uint64(numMethods), false), // numMethods
-				c.getTypeCode(types.NewPointer(typ)),                        // ptrTo
+				llvm.ConstInt(c.ctx.Int16Type(), structNumMethods, false), // numMethods
+				c.getTypeCode(types.NewPointer(typ)),                      // ptrTo
 				pkgPathPtr,
 				llvm.ConstInt(c.ctx.Int32Type(), uint64(size), false),            // size
 				llvm.ConstInt(c.ctx.Int16Type(), uint64(typ.NumFields()), false), // numFields
@@ -407,9 +468,14 @@ func (c *compilerContext) getTypeCode(typ types.Type) llvm.Value {
 				}))
 			}
 			typeFields = append(typeFields, llvm.ConstArray(structFieldType, fields))
+			if len(methods) > 0 {
+				typeFields = append(typeFields, methodSetValue)
+			}
 		case *types.Interface:
-			typeFields = []llvm.Value{c.getTypeCode(types.NewPointer(typ))}
-			// TODO: methods
+			typeFields = []llvm.Value{
+				c.getTypeCode(types.NewPointer(typ)),
+				methodSetValue,
+			}
 		case *types.Signature:
 			typeFields = []llvm.Value{c.getTypeCode(types.NewPointer(typ))}
 			// TODO: params, return values, etc
@@ -696,17 +762,11 @@ func (b *builder) createTypeAssert(expr *ssa.TypeAssert) llvm.Value {
 			// This type assertion always succeeds, so we can just set commaOk to true.
 			commaOk = llvm.ConstInt(b.ctx.Int1Type(), 1, true)
 		} else {
-			// Type assert on interface type with methods.
-			// This is a call to an interface type assert function.
-			// The interface lowering pass will define this function by filling it
-			// with a type switch over all concrete types that implement this
-			// interface, and returning whether it's one of the matched types.
-			// This is very different from how interface asserts are implemented in
-			// the main Go compiler, where the runtime checks whether the type
-			// implements each method of the interface. See:
-			// https://research.swtch.com/interfaces
-			fn := b.getInterfaceImplementsFunc(expr.AssertedType)
-			commaOk = b.CreateCall(fn.GlobalValueType(), fn, []llvm.Value{actualTypeNum}, "")
+			// Type assert on an interface type with methods.
+			// Create a call to a declared-but-not-defined function that will
+			// be lowered by the interface lowering pass into a type-ID
+			// comparison chain.
+			commaOk = b.createInterfaceTypeAssert(intf, actualTypeNum)
 		}
 	} else {
 		name, _ := getTypeCodeName(expr.AssertedType)
@@ -783,20 +843,58 @@ func (c *compilerContext) getMethodsString(itf *types.Interface) string {
 	return strings.Join(methods, "; ")
 }
 
-// getInterfaceImplementsFunc returns a declared function that works as a type
-// switch. The interface lowering pass will define this function.
-func (c *compilerContext) getInterfaceImplementsFunc(assertedType types.Type) llvm.Value {
-	s, _ := getTypeCodeName(assertedType.Underlying())
-	fnName := s + ".$typeassert"
-	llvmFn := c.mod.NamedFunction(fnName)
-	if llvmFn.IsNil() {
-		llvmFnType := llvm.FunctionType(c.ctx.Int1Type(), []llvm.Type{c.dataPtrType}, false)
-		llvmFn = llvm.AddFunction(c.mod, fnName, llvmFnType)
-		c.addStandardDeclaredAttributes(llvmFn)
-		methods := c.getMethodsString(assertedType.Underlying().(*types.Interface))
-		llvmFn.AddFunctionAttr(c.ctx.CreateStringAttribute("tinygo-methods", methods))
+// getMethodSetValue creates the method set struct value for a list of methods.
+// The struct contains a length and a sorted array of method signature pointers.
+func (c *compilerContext) getMethodSetValue(methods []*types.Func) llvm.Value {
+	// Create a sorted list of method signature global names.
+	type methodRef struct {
+		name  string
+		value llvm.Value
 	}
-	return llvmFn
+	var refs []methodRef
+	for _, method := range methods {
+		name := method.Name()
+		if !token.IsExported(name) {
+			name = method.Pkg().Path() + "." + name
+		}
+		s, _ := getTypeCodeName(method.Type())
+		globalName := "reflect/types.signature:" + name + ":" + s
+		value := c.mod.NamedGlobal(globalName)
+		if value.IsNil() {
+			value = llvm.AddGlobal(c.mod, c.ctx.Int8Type(), globalName)
+			value.SetInitializer(llvm.ConstNull(c.ctx.Int8Type()))
+			value.SetGlobalConstant(true)
+			value.SetLinkage(llvm.LinkOnceODRLinkage)
+			value.SetAlignment(1)
+			if c.Debug {
+				file := c.getDIFile("<Go type>")
+				diglobal := c.dibuilder.CreateGlobalVariableExpression(file, llvm.DIGlobalVariableExpression{
+					Name:        globalName,
+					File:        file,
+					Line:        1,
+					Type:        c.getDIType(types.Typ[types.Uint8]),
+					LocalToUnit: false,
+					Expr:        c.dibuilder.CreateExpression(nil),
+					AlignInBits: 8,
+				})
+				value.AddMetadata(0, diglobal)
+			}
+		}
+		refs = append(refs, methodRef{globalName, value})
+	}
+	sort.Slice(refs, func(i, j int) bool {
+		return refs[i].name < refs[j].name
+	})
+
+	var values []llvm.Value
+	for _, ref := range refs {
+		values = append(values, ref.value)
+	}
+
+	return c.ctx.ConstStruct([]llvm.Value{
+		llvm.ConstInt(c.uintptrType, uint64(len(values)), false),
+		llvm.ConstArray(c.dataPtrType, values),
+	}, false)
 }
 
 // getInvokeFunction returns the thunk to call the given interface method. The
@@ -823,6 +921,24 @@ func (c *compilerContext) getInvokeFunction(instr *ssa.CallCommon) llvm.Value {
 	return llvmFn
 }
 
+// createInterfaceTypeAssert creates a call to a declared-but-not-defined
+// $typeassert function for the given interface. This function will be defined
+// by the interface lowering pass as a type-ID comparison chain, avoiding the
+// need for runtime.typeImplementsMethodSet at compile time.
+func (b *builder) createInterfaceTypeAssert(intf *types.Interface, actualType llvm.Value) llvm.Value {
+	s, _ := getTypeCodeName(intf)
+	fnName := s + ".$typeassert"
+	llvmFn := b.mod.NamedFunction(fnName)
+	if llvmFn.IsNil() {
+		llvmFnType := llvm.FunctionType(b.ctx.Int1Type(), []llvm.Type{b.dataPtrType}, false)
+		llvmFn = llvm.AddFunction(b.mod, fnName, llvmFnType)
+		b.addStandardDeclaredAttributes(llvmFn)
+		methods := b.getMethodsString(intf)
+		llvmFn.AddFunctionAttr(b.ctx.CreateStringAttribute("tinygo-methods", methods))
+	}
+	return b.CreateCall(llvmFn.GlobalValueType(), llvmFn, []llvm.Value{actualType}, "")
+}
+
 // getInterfaceInvokeWrapper returns a wrapper for the given method so it can be
 // invoked from an interface. The wrapper takes in a pointer to the underlying
 // value, dereferences or unpacks it if necessary, and calls the real method.

compiler/intrinsics.go

@@ -208,6 +208,23 @@ func (b *builder) defineMathOp() {
 	b.CreateRet(result)
 }
 
+func (b *builder) defineCryptoIntrinsic() bool {
+	if b.fn.Pkg.Pkg.Path() != "crypto/internal/constanttime" {
+		return false
+	}
+
+	switch b.fn.Name() {
+	case "boolToUint8":
+		b.createFunctionStart(true)
+		param := b.getValue(b.fn.Params[0], b.fn.Pos())
+		result := b.CreateZExt(param, b.ctx.Int8Type(), "")
+		b.CreateRet(result)
+		return true
+	}
+
+	return false
+}
+
 // Implement most math/bits functions.
 //
 // This implements all the functions that operate on bits. It does not yet

compiler/llvm.go

@@ -1,10 +1,10 @@
 package compiler
 
 import (
+	"encoding/binary"
 	"fmt"
 	"go/token"
 	"go/types"
-	"math/big"
 	"strings"
 
 	"github.com/tinygo-org/tinygo/compileopts"
@@ -129,11 +129,9 @@ func (b *builder) emitPointerPack(values []llvm.Value) llvm.Value {
 		// Packed data is bigger than a pointer, so allocate it on the heap.
 		sizeValue := llvm.ConstInt(b.uintptrType, size, false)
 		align := b.targetData.ABITypeAlignment(packedType)
-		alloc := b.mod.NamedFunction("runtime.alloc")
-		packedAlloc := b.CreateCall(alloc.GlobalValueType(), alloc, []llvm.Value{
+		packedAlloc := b.createRuntimeCall(b.allocFunc(), []llvm.Value{
 			sizeValue,
 			llvm.ConstNull(b.dataPtrType),
-			llvm.Undef(b.dataPtrType), // unused context parameter
 		}, "")
 		packedAlloc.AddCallSiteAttribute(0, b.ctx.CreateEnumAttribute(llvm.AttributeKindID("align"), uint64(align)))
 		if b.NeedsStackObjects {
@@ -231,6 +229,12 @@ func (c *compilerContext) makeGlobalArray(buf []byte, name string, elementType l
 //
 // For details on what's in this value, see src/runtime/gc_precise.go.
 func (c *compilerContext) createObjectLayout(t llvm.Type, pos token.Pos) llvm.Value {
+	if !typeHasPointers(t) {
+		// There are no pointers in this type, so we can simplify the layout.
+		layout := (uint64(1) << 1) | 1
+		return llvm.ConstIntToPtr(llvm.ConstInt(c.uintptrType, layout, false), c.dataPtrType)
+	}
+
 	// Use the element type for arrays. This works even for nested arrays.
 	for {
 		kind := t.TypeKind()
@@ -248,54 +252,29 @@ func (c *compilerContext) createObjectLayout(t llvm.Type, pos token.Pos) llvm.Va
 		break
 	}
 
-	// Do a few checks to see whether we need to generate any object layout
-	// information at all.
+	// Create the pointer bitmap.
 	objectSizeBytes := c.targetData.TypeAllocSize(t)
+	pointerAlignment := uint64(c.targetData.PrefTypeAlignment(c.dataPtrType))
+	bitmapLen := objectSizeBytes / pointerAlignment
+	bitmapBytes := (bitmapLen + 7) / 8
+	bitmap := make([]byte, bitmapBytes, max(bitmapBytes, 8))
+	c.buildPointerBitmap(bitmap, pointerAlignment, pos, t, 0)
+
+	// Try to encode the layout inline.
 	pointerSize := c.targetData.TypeAllocSize(c.dataPtrType)
-	pointerAlignment := c.targetData.PrefTypeAlignment(c.dataPtrType)
-	if objectSizeBytes < pointerSize {
-		// Too small to contain a pointer.
-		layout := (uint64(1) << 1) | 1
-		return llvm.ConstIntToPtr(llvm.ConstInt(c.uintptrType, layout, false), c.dataPtrType)
-	}
-	bitmap := c.getPointerBitmap(t, pos)
-	if bitmap.BitLen() == 0 {
-		// There are no pointers in this type, so we can simplify the layout.
-		// TODO: this can be done in many other cases, e.g. when allocating an
-		// array (like [4][]byte, which repeats a slice 4 times).
-		layout := (uint64(1) << 1) | 1
-		return llvm.ConstIntToPtr(llvm.ConstInt(c.uintptrType, layout, false), c.dataPtrType)
-	}
-	if objectSizeBytes%uint64(pointerAlignment) != 0 {
-		// This shouldn't happen except for packed structs, which aren't
-		// currently used.
-		c.addError(pos, "internal error: unexpected object size for object with pointer field")
-		return llvm.ConstNull(c.dataPtrType)
-	}
-	objectSizeWords := objectSizeBytes / uint64(pointerAlignment)
-
 	pointerBits := pointerSize * 8
-	var sizeFieldBits uint64
-	switch pointerBits {
-	case 16:
-		sizeFieldBits = 4
-	case 32:
-		sizeFieldBits = 5
-	case 64:
-		sizeFieldBits = 6
-	default:
-		panic("unknown pointer size")
-	}
-	layoutFieldBits := pointerBits - 1 - sizeFieldBits
+	if bitmapLen < pointerBits {
+		rawMask := binary.LittleEndian.Uint64(bitmap[0:8])
+		layout := rawMask*pointerBits + bitmapLen
+		layout <<= 1
+		layout |= 1
 
-	// Try to emit the value as an inline integer. This is possible in most
-	// cases.
-	if objectSizeWords < layoutFieldBits {
-		// If it can be stored directly in the pointer value, do so.
-		// The runtime knows that if the least significant bit of the pointer is
-		// set, the pointer contains the value itself.
-		layout := bitmap.Uint64()<<(sizeFieldBits+1) | (objectSizeWords << 1) | 1
-		return llvm.ConstIntToPtr(llvm.ConstInt(c.uintptrType, layout, false), c.dataPtrType)
+		// Check if the layout fits.
+		layout &= 1<<pointerBits - 1
+		if (layout>>1)/pointerBits == rawMask {
+			// No set bits were shifted off.
+			return llvm.ConstIntToPtr(llvm.ConstInt(c.uintptrType, layout, false), c.dataPtrType)
+		}
 	}
 
 	// Unfortunately, the object layout is too big to fit in a pointer-sized
@@ -303,25 +282,24 @@ func (c *compilerContext) createObjectLayout(t llvm.Type, pos token.Pos) llvm.Va
 
 	// Try first whether the global already exists. All objects with a
 	// particular name have the same type, so this is possible.
-	globalName := "runtime/gc.layout:" + fmt.Sprintf("%d-%0*x", objectSizeWords, (objectSizeWords+15)/16, bitmap)
+	globalName := "runtime/gc.layout:" + fmt.Sprintf("%d-%0*x", bitmapLen, (bitmapLen+15)/16, bitmap)
 	global := c.mod.NamedGlobal(globalName)
 	if !global.IsNil() {
 		return global
 	}
 
 	// Create the global initializer.
-	bitmapBytes := make([]byte, int(objectSizeWords+7)/8)
-	bitmap.FillBytes(bitmapBytes)
-	reverseBytes(bitmapBytes) // big-endian to little-endian
-	var bitmapByteValues []llvm.Value
-	for _, b := range bitmapBytes {
-		bitmapByteValues = append(bitmapByteValues, llvm.ConstInt(c.ctx.Int8Type(), uint64(b), false))
+	bitmapByteValues := make([]llvm.Value, bitmapBytes)
+	i8 := c.ctx.Int8Type()
+	for i, b := range bitmap {
+		bitmapByteValues[i] = llvm.ConstInt(i8, uint64(b), false)
 	}
 	initializer := c.ctx.ConstStruct([]llvm.Value{
-		llvm.ConstInt(c.uintptrType, objectSizeWords, false),
-		llvm.ConstArray(c.ctx.Int8Type(), bitmapByteValues),
+		llvm.ConstInt(c.uintptrType, bitmapLen, false),
+		llvm.ConstArray(i8, bitmapByteValues),
 	}, false)
 
+	// Create the actual global.
 	global = llvm.AddGlobal(c.mod, initializer.Type(), globalName)
 	global.SetInitializer(initializer)
 	global.SetUnnamedAddr(true)
@@ -329,6 +307,7 @@ func (c *compilerContext) createObjectLayout(t llvm.Type, pos token.Pos) llvm.Va
 	global.SetLinkage(llvm.LinkOnceODRLinkage)
 	if c.targetData.PrefTypeAlignment(c.uintptrType) < 2 {
 		// AVR doesn't have alignment by default.
+		// The lowest bit must be unset to distinguish this from an inline layout.
 		global.SetAlignment(2)
 	}
 	if c.Debug && pos != token.NoPos {
@@ -360,52 +339,71 @@ func (c *compilerContext) createObjectLayout(t llvm.Type, pos token.Pos) llvm.Va
 	return global
 }
 
-// getPointerBitmap scans the given LLVM type for pointers and sets bits in a
-// bigint at the word offset that contains a pointer. This scan is recursive.
-func (c *compilerContext) getPointerBitmap(typ llvm.Type, pos token.Pos) *big.Int {
-	alignment := c.targetData.PrefTypeAlignment(c.dataPtrType)
-	switch typ.TypeKind() {
+// buildPointerBitmap scans the given LLVM type for pointers and sets bits in a
+// bitmap at the word offset that contains a pointer. This scan is recursive.
+func (c *compilerContext) buildPointerBitmap(
+	dst []byte,
+	ptrAlign uint64,
+	pos token.Pos,
+	t llvm.Type,
+	offset uint64,
+) {
+	switch t.TypeKind() {
 	case llvm.IntegerTypeKind, llvm.FloatTypeKind, llvm.DoubleTypeKind:
-		return big.NewInt(0)
+		// These types do not contain pointers.
+
 	case llvm.PointerTypeKind:
-		return big.NewInt(1)
+		// Set the corresponding position in the bitmap.
+		dst[offset/8] |= 1 << (offset % 8)
+
 	case llvm.StructTypeKind:
-		ptrs := big.NewInt(0)
-		for i, subtyp := range typ.StructElementTypes() {
-			subptrs := c.getPointerBitmap(subtyp, pos)
-			if subptrs.BitLen() == 0 {
+		// Recurse over struct elements.
+		for i, et := range t.StructElementTypes() {
+			eo := c.targetData.ElementOffset(t, i)
+			if eo%uint64(ptrAlign) != 0 {
+				if typeHasPointers(et) {
+					// This error will let the compilation fail, but by continuing
+					// the error can still easily be shown.
+					c.addError(pos, "internal error: allocated struct contains unaligned pointer")
+				}
 				continue
 			}
-			offset := c.targetData.ElementOffset(typ, i)
-			if offset%uint64(alignment) != 0 {
-				// This error will let the compilation fail, but by continuing
-				// the error can still easily be shown.
-				c.addError(pos, "internal error: allocated struct contains unaligned pointer")
-				continue
-			}
-			subptrs.Lsh(subptrs, uint(offset)/uint(alignment))
-			ptrs.Or(ptrs, subptrs)
+			c.buildPointerBitmap(
+				dst,
+				ptrAlign,
+				pos,
+				et,
+				offset+(eo/ptrAlign),
+			)
 		}
-		return ptrs
+
 	case llvm.ArrayTypeKind:
-		subtyp := typ.ElementType()
-		subptrs := c.getPointerBitmap(subtyp, pos)
-		ptrs := big.NewInt(0)
-		if subptrs.BitLen() == 0 {
-			return ptrs
+		// Recurse over array elements.
+		len := t.ArrayLength()
+		if len <= 0 {
+			return
 		}
-		elementSize := c.targetData.TypeAllocSize(subtyp)
-		if elementSize%uint64(alignment) != 0 {
-			// This error will let the compilation fail (but continues so that
-			// other errors can be shown).
-			c.addError(pos, "internal error: allocated array contains unaligned pointer")
-			return ptrs
+		et := t.ElementType()
+		elementSize := c.targetData.TypeAllocSize(et)
+		if elementSize%ptrAlign != 0 {
+			if typeHasPointers(et) {
+				// This error will let the compilation fail (but continues so that
+				// other errors can be shown).
+				c.addError(pos, "internal error: allocated array contains unaligned pointer")
+			}
+			return
 		}
-		for i := 0; i < typ.ArrayLength(); i++ {
-			ptrs.Lsh(ptrs, uint(elementSize)/uint(alignment))
-			ptrs.Or(ptrs, subptrs)
+		elementSize /= ptrAlign
+		for i := 0; i < len; i++ {
+			c.buildPointerBitmap(
+				dst,
+				ptrAlign,
+				pos,
+				et,
+				offset+uint64(i)*elementSize,
+			)
 		}
-		return ptrs
+
 	default:
 		// Should not happen.
 		panic("unknown LLVM type")

compiler/map.go

@@ -3,42 +3,28 @@ package compiler
 // This file emits the correct map intrinsics for map operations.
 
 import (
+	"fmt"
 	"go/token"
 	"go/types"
-
-	"github.com/tinygo-org/tinygo/src/tinygo"
 	"golang.org/x/tools/go/ssa"
 	"tinygo.org/x/go-llvm"
 )
 
+const hashArrayUnrollLimit = 4
+
 // 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) {
 	mapType := expr.Type().Underlying().(*types.Map)
 	keyType := mapType.Key().Underlying()
 	llvmValueType := b.getLLVMType(mapType.Elem().Underlying())
-	var llvmKeyType llvm.Type
-	var alg uint64
-	if t, ok := keyType.(*types.Basic); ok && t.Info()&types.IsString != 0 {
-		// String keys.
-		llvmKeyType = b.getLLVMType(keyType)
-		alg = uint64(tinygo.HashmapAlgorithmString)
-	} else if hashmapIsBinaryKey(keyType) {
-		// Trivially comparable keys.
-		llvmKeyType = b.getLLVMType(keyType)
-		alg = uint64(tinygo.HashmapAlgorithmBinary)
-	} else {
-		// All other keys. Implemented as map[interface{}]valueType for ease of
-		// implementation.
-		llvmKeyType = b.getLLVMRuntimeType("_interface")
-		alg = uint64(tinygo.HashmapAlgorithmInterface)
-	}
+	llvmKeyType := b.getLLVMType(keyType)
+
 	keySize := b.targetData.TypeAllocSize(llvmKeyType)
 	valueSize := b.targetData.TypeAllocSize(llvmValueType)
 	llvmKeySize := llvm.ConstInt(b.uintptrType, keySize, false)
 	llvmValueSize := llvm.ConstInt(b.uintptrType, 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, getPos(expr))
 		var err error
@@ -47,10 +33,42 @@ func (b *builder) createMakeMap(expr *ssa.MakeMap) (llvm.Value, error) {
 			return llvm.Value{}, err
 		}
 	}
-	hashmap := b.createRuntimeCall("hashmapMake", []llvm.Value{llvmKeySize, llvmValueSize, sizeHint, algEnum}, "")
+
+	// Resolve hash and equal functions for this key type. For string and
+	// binary key types, reference the corresponding runtime functions
+	// directly. For composite types, generate type-specific functions.
+	var hashFn, equalFn llvm.Value
+	if t, ok := keyType.(*types.Basic); ok && t.Info()&types.IsString != 0 {
+		hashFn = b.getRuntimeFunctionValue("hashmapStringPtrHash", hashmapKeyHashSignature())
+		equalFn = b.getRuntimeFunctionValue("hashmapStringEqual", hashmapKeyEqualSignature())
+	} else if hashmapIsBinaryKey(keyType) {
+		hashFn = b.getRuntimeFunctionValue("hash32", hashmapKeyHashSignature())
+		equalFn = b.getRuntimeFunctionValue("memequal", hashmapKeyEqualSignature())
+	} else {
+		fn := b.getOrGenerateKeyHashFunc(keyType)
+		hashFn = b.createFuncValue(fn, llvm.ConstNull(b.dataPtrType), hashmapKeyHashSignature())
+		fn = b.getOrGenerateKeyEqualFunc(keyType)
+		equalFn = b.createFuncValue(fn, llvm.ConstNull(b.dataPtrType), hashmapKeyEqualSignature())
+	}
+
+	hashmap := b.createRuntimeCall("hashmapMakeGeneric", []llvm.Value{
+		llvmKeySize, llvmValueSize, sizeHint,
+		hashFn, equalFn,
+	}, "")
 	return hashmap, nil
 }
 
+// getRuntimeFunctionValue returns a TinyGo function value (with nil context)
+// for the named runtime function.
+func (b *builder) getRuntimeFunctionValue(name string, sig *types.Signature) llvm.Value {
+	member := b.program.ImportedPackage("runtime").Members[name]
+	if member == nil {
+		panic("unknown runtime function: " + name)
+	}
+	_, llvmFn := b.getFunction(member.(*ssa.Function))
+	return b.createFuncValue(llvmFn, llvm.ConstNull(b.dataPtrType), sig)
+}
+
 // createMapLookup returns the value in a map. It calls a runtime function
 // depending on the map key type to load the map value and its comma-ok value.
 func (b *builder) createMapLookup(keyType, valueType types.Type, m, key llvm.Value, commaOk bool, pos token.Pos) (llvm.Value, error) {
@@ -72,32 +90,23 @@ func (b *builder) createMapLookup(keyType, valueType types.Type, m, key llvm.Val
 
 	// Do the lookup. How it is done depends on the key type.
 	var commaOkValue llvm.Value
-	origKeyType := keyType
 	keyType = keyType.Underlying()
 	if t, ok := keyType.(*types.Basic); ok && t.Info()&types.IsString != 0 {
 		// key is a string
 		params := []llvm.Value{m, key, mapValueAlloca, mapValueSize}
 		commaOkValue = b.createRuntimeCall("hashmapStringGet", params, "")
-	} else if hashmapIsBinaryKey(keyType) {
-		// key can be compared with runtime.memequal
-		// Store the key in an alloca, in the entry block to avoid dynamic stack
-		// growth.
+	} else {
+		// Key stored at actual type: either binary-comparable or with
+		// compiler-generated hash/equal.
 		mapKeyAlloca, mapKeySize := b.createTemporaryAlloca(key.Type(), "hashmap.key")
 		b.CreateStore(key, mapKeyAlloca)
-		b.zeroUndefBytes(b.getLLVMType(keyType), mapKeyAlloca)
-		// Fetch the value from the hashmap.
 		params := []llvm.Value{m, mapKeyAlloca, mapValueAlloca, mapValueSize}
-		commaOkValue = b.createRuntimeCall("hashmapBinaryGet", params, "")
-		b.emitLifetimeEnd(mapKeyAlloca, mapKeySize)
-	} else {
-		// Not trivially comparable using memcmp. Make it an interface instead.
-		itfKey := key
-		if _, ok := keyType.(*types.Interface); !ok {
-			// Not already an interface, so convert it to an interface now.
-			itfKey = b.createMakeInterface(key, origKeyType, pos)
+		fnName := "hashmapBinaryGet"
+		if !hashmapIsBinaryKey(keyType) {
+			fnName = "hashmapGenericGet"
 		}
-		params := []llvm.Value{m, itfKey, mapValueAlloca, mapValueSize}
-		commaOkValue = b.createRuntimeCall("hashmapInterfaceGet", params, "")
+		commaOkValue = b.createRuntimeCall(fnName, params, "")
+		b.emitLifetimeEnd(mapKeyAlloca, mapKeySize)
 	}
 
 	// Load the resulting value from the hashmap. The value is set to the zero
@@ -120,29 +129,22 @@ func (b *builder) createMapLookup(keyType, valueType types.Type, m, key llvm.Val
 func (b *builder) createMapUpdate(keyType types.Type, m, key, value llvm.Value, pos token.Pos) {
 	valueAlloca, valueSize := b.createTemporaryAlloca(value.Type(), "hashmap.value")
 	b.CreateStore(value, valueAlloca)
-	origKeyType := keyType
 	keyType = keyType.Underlying()
 	if t, ok := keyType.(*types.Basic); ok && t.Info()&types.IsString != 0 {
 		// key is a string
 		params := []llvm.Value{m, key, valueAlloca}
 		b.createRuntimeCall("hashmapStringSet", params, "")
-	} else if hashmapIsBinaryKey(keyType) {
-		// key can be compared with runtime.memequal
+	} else {
+		// Key stored at actual type.
 		keyAlloca, keySize := b.createTemporaryAlloca(key.Type(), "hashmap.key")
 		b.CreateStore(key, keyAlloca)
-		b.zeroUndefBytes(b.getLLVMType(keyType), keyAlloca)
-		params := []llvm.Value{m, keyAlloca, valueAlloca}
-		b.createRuntimeCall("hashmapBinarySet", params, "")
-		b.emitLifetimeEnd(keyAlloca, keySize)
-	} else {
-		// Key is not trivially comparable, so compare it as an interface instead.
-		itfKey := key
-		if _, ok := keyType.(*types.Interface); !ok {
-			// Not already an interface, so convert it to an interface first.
-			itfKey = b.createMakeInterface(key, origKeyType, pos)
+		fnName := "hashmapBinarySet"
+		if !hashmapIsBinaryKey(keyType) {
+			fnName = "hashmapGenericSet"
 		}
-		params := []llvm.Value{m, itfKey, valueAlloca}
-		b.createRuntimeCall("hashmapInterfaceSet", params, "")
+		params := []llvm.Value{m, keyAlloca, valueAlloca}
+		b.createRuntimeCall(fnName, params, "")
+		b.emitLifetimeEnd(keyAlloca, keySize)
 	}
 	b.emitLifetimeEnd(valueAlloca, valueSize)
 }
@@ -150,31 +152,23 @@ func (b *builder) createMapUpdate(keyType types.Type, m, key, value llvm.Value,
 // createMapDelete deletes a key from a map by calling the appropriate runtime
 // function. It is the implementation of the Go delete() builtin.
 func (b *builder) createMapDelete(keyType types.Type, m, key llvm.Value, pos token.Pos) error {
-	origKeyType := keyType
 	keyType = keyType.Underlying()
 	if t, ok := keyType.(*types.Basic); ok && t.Info()&types.IsString != 0 {
 		// key is a string
 		params := []llvm.Value{m, key}
 		b.createRuntimeCall("hashmapStringDelete", params, "")
 		return nil
-	} else if hashmapIsBinaryKey(keyType) {
+	} else {
+		// Key stored at actual type.
 		keyAlloca, keySize := b.createTemporaryAlloca(key.Type(), "hashmap.key")
 		b.CreateStore(key, keyAlloca)
-		b.zeroUndefBytes(b.getLLVMType(keyType), keyAlloca)
-		params := []llvm.Value{m, keyAlloca}
-		b.createRuntimeCall("hashmapBinaryDelete", params, "")
-		b.emitLifetimeEnd(keyAlloca, keySize)
-		return nil
-	} else {
-		// Key is not trivially comparable, so compare it as an interface
-		// instead.
-		itfKey := key
-		if _, ok := keyType.(*types.Interface); !ok {
-			// Not already an interface, so convert it to an interface first.
-			itfKey = b.createMakeInterface(key, origKeyType, pos)
+		fnName := "hashmapBinaryDelete"
+		if !hashmapIsBinaryKey(keyType) {
+			fnName = "hashmapGenericDelete"
 		}
-		params := []llvm.Value{m, itfKey}
-		b.createRuntimeCall("hashmapInterfaceDelete", params, "")
+		params := []llvm.Value{m, keyAlloca}
+		b.createRuntimeCall(fnName, params, "")
+		b.emitLifetimeEnd(keyAlloca, keySize)
 		return nil
 	}
 }
@@ -195,42 +189,15 @@ func (b *builder) createMapIteratorNext(rangeVal ssa.Value, llvmRangeVal, it llv
 	llvmKeyType := b.getLLVMType(keyType)
 	llvmValueType := b.getLLVMType(valueType)
 
-	// There is a special case in which keys are stored as an interface value
-	// instead of the value they normally are. This happens for non-trivially
-	// comparable types such as float32 or some structs.
-	isKeyStoredAsInterface := false
-	if t, ok := keyType.Underlying().(*types.Basic); ok && t.Info()&types.IsString != 0 {
-		// key is a string
-	} else if hashmapIsBinaryKey(keyType) {
-		// key can be compared with runtime.memequal
-	} else {
-		// The key is stored as an interface value, and may or may not be an
-		// interface type (for example, float32 keys are stored as an interface
-		// value).
-		if _, ok := keyType.Underlying().(*types.Interface); !ok {
-			isKeyStoredAsInterface = true
-		}
-	}
-
-	// Determine the type of the key as stored in the map.
-	llvmStoredKeyType := llvmKeyType
-	if isKeyStoredAsInterface {
-		llvmStoredKeyType = b.getLLVMRuntimeType("_interface")
-	}
+	// All key types are now stored at their declared type (no interface wrapping).
 
 	// Extract the key and value from the map.
-	mapKeyAlloca, mapKeySize := b.createTemporaryAlloca(llvmStoredKeyType, "range.key")
+	mapKeyAlloca, mapKeySize := b.createTemporaryAlloca(llvmKeyType, "range.key")
 	mapValueAlloca, mapValueSize := b.createTemporaryAlloca(llvmValueType, "range.value")
 	ok := b.createRuntimeCall("hashmapNext", []llvm.Value{llvmRangeVal, it, mapKeyAlloca, mapValueAlloca}, "range.next")
-	mapKey := b.CreateLoad(llvmStoredKeyType, mapKeyAlloca, "")
+	mapKey := b.CreateLoad(llvmKeyType, mapKeyAlloca, "")
 	mapValue := b.CreateLoad(llvmValueType, mapValueAlloca, "")
 
-	if isKeyStoredAsInterface {
-		// The key is stored as an interface but it isn't of interface type.
-		// Extract the underlying value.
-		mapKey = b.extractValueFromInterface(mapKey, llvmKeyType)
-	}
-
 	// End the lifetimes of the allocas, because we're done with them.
 	b.emitLifetimeEnd(mapKeyAlloca, mapKeySize)
 	b.emitLifetimeEnd(mapValueAlloca, mapValueSize)
@@ -250,20 +217,9 @@ func (b *builder) createMapIteratorNext(rangeVal ssa.Value, llvmRangeVal, it llv
 func hashmapIsBinaryKey(keyType types.Type) bool {
 	switch keyType := keyType.Underlying().(type) {
 	case *types.Basic:
-		// TODO: unsafe.Pointer is also a binary key, but to support that we
-		// need to fix an issue with interp first (see
-		// https://github.com/tinygo-org/tinygo/pull/4898).
-		return keyType.Info()&(types.IsBoolean|types.IsInteger) != 0
+		return keyType.Info()&(types.IsBoolean|types.IsInteger) != 0 || keyType.Kind() == types.UnsafePointer
 	case *types.Pointer:
 		return true
-	case *types.Struct:
-		for i := 0; i < keyType.NumFields(); i++ {
-			fieldType := keyType.Field(i).Type().Underlying()
-			if !hashmapIsBinaryKey(fieldType) {
-				return false
-			}
-		}
-		return true
 	case *types.Array:
 		return hashmapIsBinaryKey(keyType.Elem())
 	default:
@@ -271,68 +227,399 @@ func hashmapIsBinaryKey(keyType types.Type) bool {
 	}
 }
 
-func (b *builder) zeroUndefBytes(llvmType llvm.Type, ptr llvm.Value) error {
-	// We know that hashmapIsBinaryKey is true, so we only have to handle those types that can show up there.
-	// To zero all undefined bytes, we iterate over all the fields in the type.  For each element, compute the
-	// offset of that element.  If it's Basic type, there are no internal padding bytes.  For compound types, we recurse to ensure
-	// we handle nested types.  Next, we determine if there are any padding bytes before the next
-	// element and zero those as well.
+// hashmapKeyHashSignature returns the Go type signature for hashmap key hash
+// functions: func(key unsafe.Pointer, size, seed uintptr) uint32
+func hashmapKeyHashSignature() *types.Signature {
+	return types.NewSignatureType(nil, nil, nil,
+		types.NewTuple(
+			types.NewVar(token.NoPos, nil, "key", types.Typ[types.UnsafePointer]),
+			types.NewVar(token.NoPos, nil, "size", types.Typ[types.Uintptr]),
+			types.NewVar(token.NoPos, nil, "seed", types.Typ[types.Uintptr]),
+		),
+		types.NewTuple(
+			types.NewVar(token.NoPos, nil, "", types.Typ[types.Uint32]),
+		),
+		false,
+	)
+}
 
-	zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
+// hashmapKeyEqualSignature returns the Go type signature for hashmap key equal
+// functions: func(x, y unsafe.Pointer, n uintptr) bool
+func hashmapKeyEqualSignature() *types.Signature {
+	return types.NewSignatureType(nil, nil, nil,
+		types.NewTuple(
+			types.NewVar(token.NoPos, nil, "x", types.Typ[types.UnsafePointer]),
+			types.NewVar(token.NoPos, nil, "y", types.Typ[types.UnsafePointer]),
+			types.NewVar(token.NoPos, nil, "n", types.Typ[types.Uintptr]),
+		),
+		types.NewTuple(
+			types.NewVar(token.NoPos, nil, "", types.Typ[types.Bool]),
+		),
+		false,
+	)
+}
 
-	switch llvmType.TypeKind() {
-	case llvm.IntegerTypeKind:
-		// no padding bytes
-		return nil
-	case llvm.PointerTypeKind:
-		// mo padding bytes
-		return nil
-	case llvm.ArrayTypeKind:
-		llvmArrayType := llvmType
-		llvmElemType := llvmType.ElementType()
+// hashmapKeyFuncName returns a canonical name for a generated hash or equal
+// function based on the key type's underlying structure. Named types are
+// replaced with their underlying types so that structurally identical key
+// types (e.g., struct{i1; str1} and struct{i2; str2} where both i1, i2 are
+// int and str1, str2 are string) share the same generated function.
+func hashmapKeyFuncName(prefix string, keyType types.Type) string {
+	return prefix + "." + hashmapCanonicalTypeName(keyType)
+}
 
-		for i := 0; i < llvmArrayType.ArrayLength(); i++ {
-			idx := llvm.ConstInt(b.uintptrType, uint64(i), false)
-			elemPtr := b.CreateInBoundsGEP(llvmArrayType, ptr, []llvm.Value{zero, idx}, "")
-
-			// zero any padding bytes in this element
-			b.zeroUndefBytes(llvmElemType, elemPtr)
+// hashmapCanonicalTypeName returns a string representation of the hash/equal
+// operations needed for a type, stripping named types where the operation does
+// not depend on the name. Pointer and channel names do not include the element
+// type because their hash/equal operations only use the pointer word.
+func hashmapCanonicalTypeName(t types.Type) string {
+	switch t := t.Underlying().(type) {
+	case *types.Basic:
+		return t.Name()
+	case *types.Pointer:
+		return "*"
+	case *types.Chan:
+		switch t.Dir() {
+		case types.SendRecv:
+			return "chan"
+		case types.SendOnly:
+			return "chan<-"
+		case types.RecvOnly:
+			return "<-chan"
 		}
-
-	case llvm.StructTypeKind:
-		llvmStructType := llvmType
-		numFields := llvmStructType.StructElementTypesCount()
-		llvmElementTypes := llvmStructType.StructElementTypes()
-
-		for i := 0; i < numFields; i++ {
-			idx := llvm.ConstInt(b.ctx.Int32Type(), uint64(i), false)
-			elemPtr := b.CreateInBoundsGEP(llvmStructType, ptr, []llvm.Value{zero, idx}, "")
-
-			// zero any padding bytes in this field
-			llvmElemType := llvmElementTypes[i]
-			b.zeroUndefBytes(llvmElemType, elemPtr)
-
-			// zero any padding bytes before the next field, if any
-			offset := b.targetData.ElementOffset(llvmStructType, i)
-			storeSize := b.targetData.TypeStoreSize(llvmElemType)
-			fieldEndOffset := offset + storeSize
-
-			var nextOffset uint64
-			if i < numFields-1 {
-				nextOffset = b.targetData.ElementOffset(llvmStructType, i+1)
-			} else {
-				// Last field?  Next offset is the total size of the allocate struct.
-				nextOffset = b.targetData.TypeAllocSize(llvmStructType)
-			}
-
-			if fieldEndOffset != nextOffset {
-				n := llvm.ConstInt(b.uintptrType, nextOffset-fieldEndOffset, false)
-				llvmStoreSize := llvm.ConstInt(b.uintptrType, storeSize, false)
-				paddingStart := b.CreateInBoundsGEP(b.ctx.Int8Type(), elemPtr, []llvm.Value{llvmStoreSize}, "")
-				b.createRuntimeCall("memzero", []llvm.Value{paddingStart, n}, "")
-			}
+	case *types.Interface:
+		if t.NumMethods() == 0 {
+			return "interface{}"
 		}
+		return t.String()
+	case *types.Struct:
+		s := "struct{"
+		for i := 0; i < t.NumFields(); i++ {
+			if i > 0 {
+				s += "; "
+			}
+			s += hashmapCanonicalTypeName(t.Field(i).Type())
+		}
+		return s + "}"
+	case *types.Array:
+		return fmt.Sprintf("[%d]%s", t.Len(), hashmapCanonicalTypeName(t.Elem()))
+	}
+	return t.String()
+}
+
+// getOrGenerateKeyHashFunc returns an LLVM function that computes the hash
+// of a key of the given type. The function is generated on first call and
+// cached in the module.
+func (b *builder) getOrGenerateKeyHashFunc(keyType types.Type) llvm.Value {
+	name := hashmapKeyFuncName("hashmapKeyHash", keyType)
+	if fn := b.mod.NamedFunction(name); !fn.IsNil() {
+		return fn
 	}
 
-	return nil
+	// Create the LLVM function type:
+	// (key ptr, size uintptr, seed uintptr, context ptr) -> i32
+	fnType := llvm.FunctionType(b.ctx.Int32Type(), []llvm.Type{
+		b.dataPtrType, b.uintptrType, b.uintptrType, b.dataPtrType,
+	}, false)
+	fn := llvm.AddFunction(b.mod, name, fnType)
+	fn.SetLinkage(llvm.LinkOnceODRLinkage)
+	fn.SetUnnamedAddr(true)
+	b.addStandardAttributes(fn)
+
+	// Generate the function body.
+	savedBlock := b.GetInsertBlock()
+	defer b.SetInsertPointAtEnd(savedBlock)
+
+	entry := b.ctx.AddBasicBlock(fn, "entry")
+	b.SetInsertPointAtEnd(entry)
+
+	keyPtr := fn.Param(0)
+	seed := fn.Param(2)
+	llvmKeyType := b.getLLVMType(keyType)
+	hash := b.generateKeyHash(keyType, llvmKeyType, keyPtr, seed)
+	b.CreateRet(hash)
+
+	return fn
+}
+
+// getOrGenerateKeyEqualFunc returns an LLVM function that compares two keys
+// of the given type for equality. The function is generated on first call
+// and cached in the module.
+func (b *builder) getOrGenerateKeyEqualFunc(keyType types.Type) llvm.Value {
+	name := hashmapKeyFuncName("hashmapKeyEqual", keyType)
+	if fn := b.mod.NamedFunction(name); !fn.IsNil() {
+		return fn
+	}
+
+	// Create the LLVM function type:
+	// (x ptr, y ptr, n uintptr, context ptr) -> i1
+	fnType := llvm.FunctionType(b.ctx.Int1Type(), []llvm.Type{
+		b.dataPtrType, b.dataPtrType, b.uintptrType, b.dataPtrType,
+	}, false)
+	fn := llvm.AddFunction(b.mod, name, fnType)
+	fn.SetLinkage(llvm.LinkOnceODRLinkage)
+	fn.SetUnnamedAddr(true)
+	b.addStandardAttributes(fn)
+
+	// Generate the function body.
+	savedBlock := b.GetInsertBlock()
+	defer b.SetInsertPointAtEnd(savedBlock)
+
+	entry := b.ctx.AddBasicBlock(fn, "entry")
+	b.SetInsertPointAtEnd(entry)
+
+	xPtr := fn.Param(0)
+	yPtr := fn.Param(1)
+	llvmKeyType := b.getLLVMType(keyType)
+	result := b.generateKeyEqual(keyType, llvmKeyType, xPtr, yPtr, fn)
+	b.CreateRet(result)
+
+	return fn
+}
+
+// generateKeyHash generates IR that hashes a key value. Returns the i32 hash.
+func (b *builder) generateKeyHash(keyType types.Type, llvmKeyType llvm.Type, keyPtr llvm.Value, seed llvm.Value) llvm.Value {
+	switch keyType := keyType.Underlying().(type) {
+	case *types.Basic:
+		if keyType.Info()&types.IsString != 0 {
+			// Hash the string contents. The size parameter is unused by
+			// hashmapStringPtrHash (it dereferences the string header to
+			// get the actual length), but we pass it for signature
+			// consistency with other hash functions.
+			size := llvm.ConstInt(b.uintptrType, b.targetData.TypeAllocSize(llvmKeyType), false)
+			return b.createRuntimeCall("hashmapStringPtrHash", []llvm.Value{keyPtr, size, seed}, "hash")
+		}
+		if keyType.Info()&types.IsFloat != 0 {
+			// Float hash: normalizes -0 to +0 before hashing.
+			if keyType.Kind() == types.Float32 {
+				return b.createRuntimeCall("hashmapFloat32Hash", []llvm.Value{keyPtr, seed}, "hash")
+			}
+			return b.createRuntimeCall("hashmapFloat64Hash", []llvm.Value{keyPtr, seed}, "hash")
+		}
+		if keyType.Info()&types.IsComplex != 0 {
+			// Complex hash: hash real and imaginary parts as floats.
+			if keyType.Kind() == types.Complex64 {
+				realPtr := keyPtr
+				imagPtr := b.CreateInBoundsGEP(b.ctx.Int8Type(), keyPtr, []llvm.Value{
+					llvm.ConstInt(b.uintptrType, 4, false),
+				}, "")
+				realHash := b.createRuntimeCall("hashmapFloat32Hash", []llvm.Value{realPtr, seed}, "hash.real")
+				imagHash := b.createRuntimeCall("hashmapFloat32Hash", []llvm.Value{imagPtr, seed}, "hash.imag")
+				return b.CreateXor(realHash, imagHash, "")
+			}
+			realPtr := keyPtr
+			imagPtr := b.CreateInBoundsGEP(b.ctx.Int8Type(), keyPtr, []llvm.Value{
+				llvm.ConstInt(b.uintptrType, 8, false),
+			}, "")
+			realHash := b.createRuntimeCall("hashmapFloat64Hash", []llvm.Value{realPtr, seed}, "hash.real")
+			imagHash := b.createRuntimeCall("hashmapFloat64Hash", []llvm.Value{imagPtr, seed}, "hash.imag")
+			return b.CreateXor(realHash, imagHash, "")
+		}
+		// Integer/boolean: hash the raw bytes.
+		size := llvm.ConstInt(b.uintptrType, b.targetData.TypeAllocSize(llvmKeyType), false)
+		return b.createRuntimeCall("hash32", []llvm.Value{keyPtr, size, seed}, "hash")
+	case *types.Pointer, *types.Chan:
+		// Pointers and channels: hash as raw pointer-sized bytes.
+		size := llvm.ConstInt(b.uintptrType, b.targetData.TypeAllocSize(llvmKeyType), false)
+		return b.createRuntimeCall("hash32", []llvm.Value{keyPtr, size, seed}, "hash")
+	case *types.Interface:
+		// Interface: use runtime reflection-based hash.
+		size := llvm.ConstInt(b.uintptrType, b.targetData.TypeAllocSize(llvmKeyType), false)
+		return b.createRuntimeCall("hashmapInterfacePtrHash", []llvm.Value{keyPtr, size, seed}, "hash")
+	case *types.Struct:
+		hash := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
+		zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
+		for i := 0; i < keyType.NumFields(); i++ {
+			if keyType.Field(i).Name() == "_" {
+				continue // blank fields are ignored in Go equality
+			}
+			fieldType := keyType.Field(i).Type()
+			llvmFieldType := b.getLLVMType(fieldType)
+			if b.targetData.TypeAllocSize(llvmFieldType) == 0 {
+				continue // skip zero-sized fields
+			}
+			idx := llvm.ConstInt(b.ctx.Int32Type(), uint64(i), false)
+			fieldPtr := b.CreateInBoundsGEP(llvmKeyType, keyPtr, []llvm.Value{zero, idx}, "")
+			fieldHash := b.generateKeyHash(fieldType, llvmFieldType, fieldPtr, seed)
+			hash = b.CreateXor(hash, fieldHash, "")
+		}
+		return hash
+	case *types.Array:
+		elemType := keyType.Elem()
+		llvmElemType := b.getLLVMType(elemType)
+		arrayLen := keyType.Len()
+		if hashmapIsBinaryKey(elemType) {
+			// All elements are binary-comparable; hash the entire array as raw bytes.
+			size := llvm.ConstInt(b.uintptrType, b.targetData.TypeAllocSize(llvmKeyType), false)
+			return b.createRuntimeCall("hash32", []llvm.Value{keyPtr, size, seed}, "hash")
+		}
+		if arrayLen == 0 {
+			return llvm.ConstInt(b.ctx.Int32Type(), 0, false)
+		}
+		if arrayLen <= hashArrayUnrollLimit {
+			hash := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
+			zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
+			for i := 0; i < int(arrayLen); i++ {
+				idx := llvm.ConstInt(b.uintptrType, uint64(i), false)
+				elemPtr := b.CreateInBoundsGEP(llvmKeyType, keyPtr, []llvm.Value{zero, idx}, "")
+				elemHash := b.generateKeyHash(elemType, llvmElemType, elemPtr, seed)
+				hash = b.CreateXor(hash, elemHash, "")
+			}
+			return hash
+		}
+		initHash := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
+		zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
+
+		loopEntry := b.GetInsertBlock()
+		loopBody := b.ctx.AddBasicBlock(loopEntry.Parent(), "hash.array.body")
+		loopDone := b.ctx.AddBasicBlock(loopEntry.Parent(), "hash.array.done")
+
+		b.CreateBr(loopBody)
+		b.SetInsertPointAtEnd(loopBody)
+
+		phiI := b.CreatePHI(b.uintptrType, "i")
+		phiHash := b.CreatePHI(b.ctx.Int32Type(), "hash.acc")
+
+		elemPtr := b.CreateInBoundsGEP(llvmKeyType, keyPtr, []llvm.Value{zero, phiI}, "")
+		elemHash := b.generateKeyHash(elemType, llvmElemType, elemPtr, seed)
+		newHash := b.CreateXor(phiHash, elemHash, "")
+		nextI := b.CreateAdd(phiI, llvm.ConstInt(b.uintptrType, 1, false), "")
+		cond := b.CreateICmp(llvm.IntULT, nextI, llvm.ConstInt(b.uintptrType, uint64(arrayLen), false), "")
+		b.CreateCondBr(cond, loopBody, loopDone)
+
+		bodyEnd := b.GetInsertBlock()
+		phiI.AddIncoming([]llvm.Value{llvm.ConstInt(b.uintptrType, 0, false), nextI},
+			[]llvm.BasicBlock{loopEntry, bodyEnd})
+		phiHash.AddIncoming([]llvm.Value{initHash, newHash},
+			[]llvm.BasicBlock{loopEntry, bodyEnd})
+
+		b.SetInsertPointAtEnd(loopDone)
+		return newHash
+	default:
+		panic(fmt.Sprintf("unhandled key type for hash generation: %T", keyType))
+	}
+}
+
+// generateKeyEqual generates IR that compares two key values for equality.
+// Returns an i1 result.
+func (b *builder) generateKeyEqual(keyType types.Type, llvmKeyType llvm.Type, xPtr, yPtr llvm.Value, fn llvm.Value) llvm.Value {
+	switch keyType := keyType.Underlying().(type) {
+	case *types.Basic:
+		if keyType.Info()&types.IsString != 0 {
+			// Compare strings: load both string headers and compare.
+			xStr := b.CreateLoad(llvmKeyType, xPtr, "x.str")
+			yStr := b.CreateLoad(llvmKeyType, yPtr, "y.str")
+			return b.createRuntimeCall("stringEqual", []llvm.Value{xStr, yStr}, "eq")
+		}
+		if keyType.Info()&types.IsFloat != 0 {
+			// Float equality: fcmp oeq handles -0==+0 (true) and NaN==NaN (false).
+			xVal := b.CreateLoad(llvmKeyType, xPtr, "x.float")
+			yVal := b.CreateLoad(llvmKeyType, yPtr, "y.float")
+			return b.CreateFCmp(llvm.FloatOEQ, xVal, yVal, "eq")
+		}
+		if keyType.Info()&types.IsComplex != 0 {
+			// Complex equality: both real and imaginary parts must be equal.
+			var floatType llvm.Type
+			if keyType.Kind() == types.Complex64 {
+				floatType = b.ctx.FloatType()
+			} else {
+				floatType = b.ctx.DoubleType()
+			}
+			floatSize := b.targetData.TypeAllocSize(floatType)
+			imagOffset := llvm.ConstInt(b.uintptrType, floatSize, false)
+			// Real parts
+			xReal := b.CreateLoad(floatType, xPtr, "x.real")
+			yReal := b.CreateLoad(floatType, yPtr, "y.real")
+			realEq := b.CreateFCmp(llvm.FloatOEQ, xReal, yReal, "eq.real")
+			// Imaginary parts
+			xImagPtr := b.CreateInBoundsGEP(b.ctx.Int8Type(), xPtr, []llvm.Value{imagOffset}, "")
+			yImagPtr := b.CreateInBoundsGEP(b.ctx.Int8Type(), yPtr, []llvm.Value{imagOffset}, "")
+			xImag := b.CreateLoad(floatType, xImagPtr, "x.imag")
+			yImag := b.CreateLoad(floatType, yImagPtr, "y.imag")
+			imagEq := b.CreateFCmp(llvm.FloatOEQ, xImag, yImag, "eq.imag")
+			return b.CreateAnd(realEq, imagEq, "")
+		}
+		// Integer/boolean: compare raw bytes.
+		size := llvm.ConstInt(b.uintptrType, b.targetData.TypeAllocSize(llvmKeyType), false)
+		return b.createRuntimeCall("memequal", []llvm.Value{xPtr, yPtr, size}, "eq")
+	case *types.Pointer, *types.Chan:
+		// Pointers and channels: compare as raw pointer-sized bytes.
+		size := llvm.ConstInt(b.uintptrType, b.targetData.TypeAllocSize(llvmKeyType), false)
+		return b.createRuntimeCall("memequal", []llvm.Value{xPtr, yPtr, size}, "eq")
+	case *types.Interface:
+		// Interface: use runtime interface equality.
+		size := llvm.ConstInt(b.uintptrType, b.targetData.TypeAllocSize(llvmKeyType), false)
+		return b.createRuntimeCall("hashmapInterfaceEqual", []llvm.Value{xPtr, yPtr, size}, "eq")
+	case *types.Struct:
+		result := llvm.ConstInt(b.ctx.Int1Type(), 1, false) // start with true
+		zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
+		for i := 0; i < keyType.NumFields(); i++ {
+			if keyType.Field(i).Name() == "_" {
+				continue // blank fields are ignored in Go equality
+			}
+			fieldType := keyType.Field(i).Type()
+			llvmFieldType := b.getLLVMType(fieldType)
+			if b.targetData.TypeAllocSize(llvmFieldType) == 0 {
+				continue // skip zero-sized fields
+			}
+			idx := llvm.ConstInt(b.ctx.Int32Type(), uint64(i), false)
+			xFieldPtr := b.CreateInBoundsGEP(llvmKeyType, xPtr, []llvm.Value{zero, idx}, "")
+			yFieldPtr := b.CreateInBoundsGEP(llvmKeyType, yPtr, []llvm.Value{zero, idx}, "")
+			fieldEq := b.generateKeyEqual(fieldType, llvmFieldType, xFieldPtr, yFieldPtr, fn)
+			result = b.CreateAnd(result, fieldEq, "")
+		}
+		return result
+	case *types.Array:
+		elemType := keyType.Elem()
+		llvmElemType := b.getLLVMType(elemType)
+		arrayLen := keyType.Len()
+		if hashmapIsBinaryKey(elemType) {
+			// All elements are binary-comparable; compare the entire array.
+			size := llvm.ConstInt(b.uintptrType, b.targetData.TypeAllocSize(llvmKeyType), false)
+			return b.createRuntimeCall("memequal", []llvm.Value{xPtr, yPtr, size}, "eq")
+		}
+		if arrayLen == 0 {
+			return llvm.ConstInt(b.ctx.Int1Type(), 1, false)
+		}
+		if arrayLen <= hashArrayUnrollLimit {
+			result := llvm.ConstInt(b.ctx.Int1Type(), 1, false)
+			zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
+			for i := 0; i < int(arrayLen); i++ {
+				idx := llvm.ConstInt(b.uintptrType, uint64(i), false)
+				xElemPtr := b.CreateInBoundsGEP(llvmKeyType, xPtr, []llvm.Value{zero, idx}, "")
+				yElemPtr := b.CreateInBoundsGEP(llvmKeyType, yPtr, []llvm.Value{zero, idx}, "")
+				elemEq := b.generateKeyEqual(elemType, llvmElemType, xElemPtr, yElemPtr, fn)
+				result = b.CreateAnd(result, elemEq, "")
+			}
+			return result
+		}
+		zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
+
+		loopEntry := b.GetInsertBlock()
+		loopBody := b.ctx.AddBasicBlock(loopEntry.Parent(), "eq.array.body")
+		loopDone := b.ctx.AddBasicBlock(loopEntry.Parent(), "eq.array.done")
+
+		b.CreateBr(loopBody)
+		b.SetInsertPointAtEnd(loopBody)
+
+		phiI := b.CreatePHI(b.uintptrType, "i")
+
+		xElemPtr := b.CreateInBoundsGEP(llvmKeyType, xPtr, []llvm.Value{zero, phiI}, "")
+		yElemPtr := b.CreateInBoundsGEP(llvmKeyType, yPtr, []llvm.Value{zero, phiI}, "")
+		elemEq := b.generateKeyEqual(elemType, llvmElemType, xElemPtr, yElemPtr, fn)
+
+		nextI := b.CreateAdd(phiI, llvm.ConstInt(b.uintptrType, 1, false), "")
+		atEnd := b.CreateICmp(llvm.IntUGE, nextI, llvm.ConstInt(b.uintptrType, uint64(arrayLen), false), "")
+		exitLoop := b.CreateOr(atEnd, b.CreateNot(elemEq, ""), "")
+		b.CreateCondBr(exitLoop, loopDone, loopBody)
+
+		bodyEnd := b.GetInsertBlock()
+		phiI.AddIncoming([]llvm.Value{llvm.ConstInt(b.uintptrType, 0, false), nextI},
+			[]llvm.BasicBlock{loopEntry, bodyEnd})
+
+		b.SetInsertPointAtEnd(loopDone)
+		return elemEq
+	default:
+		panic(fmt.Sprintf("unhandled key type for equal generation: %T", keyType))
+	}
 }

compiler/symbol.go

@@ -34,6 +34,7 @@ type functionInfo struct {
 	interrupt     bool       // go:interrupt
 	nobounds      bool       // go:nobounds
 	noescape      bool       // go:noescape
+	noheap        bool       // go:noheap
 	variadic      bool       // go:variadic (CGo only)
 	inline        inlineType // go:inline
 }
@@ -161,7 +162,7 @@ func (c *compilerContext) getFunction(fn *ssa.Function) (llvm.Type, llvm.Value)
 		llvmFn.AddAttributeAtIndex(1, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("nocapture"), 0))
 	case "machine.keepAliveNoEscape", "machine.unsafeNoEscape":
 		llvmFn.AddAttributeAtIndex(1, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("nocapture"), 0))
-	case "runtime.alloc":
+	case "runtime.alloc", "runtime.alloc_noheap":
 		// Tell the optimizer that runtime.alloc is an allocator, meaning that it
 		// returns values that are never null and never alias to an existing value.
 		for _, attrName := range []string{"noalias", "nonnull"} {
@@ -190,6 +191,31 @@ func (c *compilerContext) getFunction(fn *ssa.Function) (llvm.Type, llvm.Value)
 	case "runtime.stringFromRunes":
 		llvmFn.AddAttributeAtIndex(1, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("nocapture"), 0))
 		llvmFn.AddAttributeAtIndex(1, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("readonly"), 0))
+	case "runtime.hashmapSet":
+		// The key (param 2) and value (param 3) pointers are only read via
+		// memcpy/hash/equal and are never captured. The indirect calls
+		// through m.keyHash and m.keyEqual function pointers prevent LLVM's
+		// functionattrs pass from inferring this automatically.
+		llvmFn.AddAttributeAtIndex(2, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("nocapture"), 0))
+		llvmFn.AddAttributeAtIndex(3, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("nocapture"), 0))
+	case "runtime.hashmapGet":
+		// The key (param 2) is read-only and never captured.
+		// The value (param 3) is written to (receives the result) but never captured.
+		llvmFn.AddAttributeAtIndex(2, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("nocapture"), 0))
+		llvmFn.AddAttributeAtIndex(3, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("nocapture"), 0))
+	case "runtime.hashmapDelete":
+		// The key (param 2) is read-only and never captured.
+		llvmFn.AddAttributeAtIndex(2, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("nocapture"), 0))
+	case "runtime.hashmapGenericSet":
+		// Same as hashmapBinarySet: key (param 2) and value (param 3) are
+		// not captured.
+		llvmFn.AddAttributeAtIndex(2, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("nocapture"), 0))
+		llvmFn.AddAttributeAtIndex(3, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("nocapture"), 0))
+	case "runtime.hashmapGenericGet":
+		llvmFn.AddAttributeAtIndex(2, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("nocapture"), 0))
+		llvmFn.AddAttributeAtIndex(3, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("nocapture"), 0))
+	case "runtime.hashmapGenericDelete":
+		llvmFn.AddAttributeAtIndex(2, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("nocapture"), 0))
 	case "runtime.trackPointer":
 		// This function is necessary for tracking pointers on the stack in a
 		// portable way (see gc_stack_portable.go). Indicate to the optimizer
@@ -451,6 +477,9 @@ func (c *compilerContext) parsePragmas(info *functionInfo, f *ssa.Function) {
 			if len(f.Blocks) == 0 {
 				info.noescape = true
 			}
+		case "//go:noheap":
+			// Ensure this function does not allocate on the heap.
+			info.noheap = true
 		case "//go:variadic":
 			// The //go:variadic pragma is emitted by the CGo preprocessing
 			// pass for C variadic functions. This includes both explicit
@@ -540,7 +569,7 @@ func (c *compilerContext) isValidWasmType(typ types.Type, site wasmSite) bool {
 		}
 		for i := 0; i < typ.NumFields(); i++ {
 			ftyp := typ.Field(i).Type()
-			if ftyp.String() == "structs.HostLayout" {
+			if types.Unalias(ftyp).String() == "structs.HostLayout" {
 				hasHostLayout = true
 				continue
 			}

compiler/syscall.go

@@ -349,6 +349,130 @@ func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 	}
 }
 
+// createSyscalln emits instructions for the syscall.syscalln function on
+// Windows. This handles the variadic calling convention used in Go 1.26+:
+//
+//	func syscalln(fn, n uintptr, args ...uintptr) (r1, r2 uintptr, err Errno)
+//
+// The function generates a switch on n to dispatch to the correct fixed-argument
+// function pointer call with SetLastError(0)/GetLastError() wrapping.
+func (b *builder) createSyscalln(call *ssa.CallCommon) (llvm.Value, error) {
+	const maxArgs = 18 // Windows syscalls support up to 18 args
+
+	isI386 := strings.HasPrefix(b.Triple, "i386-")
+
+	// Get the function pointer (call.Args[0]) and n (call.Args[1]).
+	fn := b.getValue(call.Args[0], getPos(call))
+	fnPtr := b.CreateIntToPtr(fn, b.dataPtrType, "")
+	n := b.getValue(call.Args[1], getPos(call))
+
+	// Get the variadic args slice (call.Args[2]).
+	// In SSA, the variadic slice is the third argument.
+	var argsPtr llvm.Value
+	if len(call.Args) > 2 {
+		argsSlice := b.getValue(call.Args[2], getPos(call))
+		argsPtr = b.CreateExtractValue(argsSlice, 0, "args.data")
+	} else {
+		argsPtr = llvm.ConstNull(b.dataPtrType)
+	}
+
+	// Prepare SetLastError and GetLastError.
+	setLastError := b.mod.NamedFunction("SetLastError")
+	if setLastError.IsNil() {
+		llvmType := llvm.FunctionType(b.ctx.VoidType(), []llvm.Type{b.ctx.Int32Type()}, false)
+		setLastError = llvm.AddFunction(b.mod, "SetLastError", llvmType)
+		if isI386 {
+			setLastError.SetFunctionCallConv(llvm.X86StdcallCallConv)
+		}
+	}
+	getLastError := b.mod.NamedFunction("GetLastError")
+	if getLastError.IsNil() {
+		llvmType := llvm.FunctionType(b.ctx.Int32Type(), nil, false)
+		getLastError = llvm.AddFunction(b.mod, "GetLastError", llvmType)
+		if isI386 {
+			getLastError.SetFunctionCallConv(llvm.X86StdcallCallConv)
+		}
+	}
+
+	retType := b.ctx.StructType([]llvm.Type{b.uintptrType, b.uintptrType, b.uintptrType}, false)
+
+	// Create the merge block where all cases converge.
+	mergeBB := b.insertBasicBlock("syscalln.merge")
+
+	// Create the default (panic) block.
+	panicBB := b.insertBasicBlock("syscalln.panic")
+
+	// Create the switch on n.
+	sw := b.CreateSwitch(n, panicBB, maxArgs+1)
+
+	// We'll collect blocks and values for the PHI node.
+	var incomingVals []llvm.Value
+	var incomingBlocks []llvm.BasicBlock
+
+	// Generate a case for each arg count 0..maxArgs.
+	for i := 0; i <= maxArgs; i++ {
+		caseBB := b.insertBasicBlock("syscalln.case" + strconv.Itoa(i))
+		sw.AddCase(llvm.ConstInt(b.uintptrType, uint64(i), false), caseBB)
+		b.SetInsertPointAtEnd(caseBB)
+
+		// Load args[0] through args[i-1] from the slice data pointer.
+		var params []llvm.Value
+		var paramTypes []llvm.Type
+		for j := 0; j < i; j++ {
+			gep := b.CreateInBoundsGEP(b.uintptrType, argsPtr, []llvm.Value{
+				llvm.ConstInt(b.ctx.Int32Type(), uint64(j), false),
+			}, "")
+			arg := b.CreateLoad(b.uintptrType, gep, "")
+			params = append(params, arg)
+			paramTypes = append(paramTypes, b.uintptrType)
+		}
+
+		// SetLastError(0)
+		setCall := b.CreateCall(setLastError.GlobalValueType(), setLastError, []llvm.Value{llvm.ConstNull(b.ctx.Int32Type())}, "")
+		var sp llvm.Value
+		if isI386 {
+			setCall.SetInstructionCallConv(llvm.X86StdcallCallConv)
+			sp = b.readStackPointer()
+		}
+
+		// Call fn(args...)
+		fnType := llvm.FunctionType(b.uintptrType, paramTypes, false)
+		syscallResult := b.CreateCall(fnType, fnPtr, params, "")
+		if isI386 {
+			syscallResult.SetInstructionCallConv(llvm.X86StdcallCallConv)
+			b.writeStackPointer(sp)
+		}
+
+		// err = GetLastError()
+		errResult := b.CreateCall(getLastError.GlobalValueType(), getLastError, nil, "err")
+		if isI386 {
+			errResult.SetInstructionCallConv(llvm.X86StdcallCallConv)
+		}
+		if b.uintptrType != b.ctx.Int32Type() {
+			errResult = b.CreateZExt(errResult, b.uintptrType, "err.uintptr")
+		}
+
+		// Build {r1, 0, err}
+		result := llvm.ConstNull(retType)
+		result = b.CreateInsertValue(result, syscallResult, 0, "")
+		result = b.CreateInsertValue(result, errResult, 2, "")
+
+		incomingVals = append(incomingVals, result)
+		incomingBlocks = append(incomingBlocks, b.Builder.GetInsertBlock())
+		b.CreateBr(mergeBB)
+	}
+
+	// Panic block for n > maxArgs.
+	b.SetInsertPointAtEnd(panicBB)
+	b.CreateUnreachable()
+
+	// Merge block: PHI node to select the result.
+	b.SetInsertPointAtEnd(mergeBB)
+	phi := b.CreatePHI(retType, "syscalln.result")
+	phi.AddIncoming(incomingVals, incomingBlocks)
+	return phi, nil
+}
+
 // createRawSyscallNoError emits instructions for the Linux-specific
 // syscall.rawSyscallNoError function.
 func (b *builder) createRawSyscallNoError(call *ssa.CallCommon) (llvm.Value, error) {

compiler/testdata/basic.ll

@@ -10,33 +10,30 @@ target triple = "wasm32-unknown-wasi"
 @main.a = hidden global { ptr, i32, i32 } zeroinitializer, align 4
 @main.b = hidden global [2 x ptr] zeroinitializer, align 4
 
-; Function Attrs: allockind("alloc,zeroed") allocsize(0)
-declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #0
-
-declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #1
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.init(ptr %context) unnamed_addr #2 {
+define hidden void @main.init(ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.addInt(i32 %x, i32 %y, ptr %context) unnamed_addr #2 {
+define hidden i32 @main.addInt(i32 %x, i32 %y, ptr %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, ptr %context) unnamed_addr #2 {
+define hidden i1 @main.equalInt(i32 %x, i32 %y, ptr %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, ptr %context) unnamed_addr #2 {
+define hidden i32 @main.divInt(i32 %x, i32 %y, ptr %context) unnamed_addr #1 {
 entry:
   %0 = icmp eq i32 %y, 0
   br i1 %0, label %divbyzero.throw, label %divbyzero.next
@@ -50,14 +47,14 @@ divbyzero.next:                                   ; preds = %entry
   ret i32 %5
 
 divbyzero.throw:                                  ; preds = %entry
-  call void @runtime.divideByZeroPanic(ptr undef) #3
+  call void @runtime.divideByZeroPanic(ptr undef) #2
   unreachable
 }
 
-declare void @runtime.divideByZeroPanic(ptr) #1
+declare void @runtime.divideByZeroPanic(ptr) #0
 
 ; Function Attrs: nounwind
-define hidden i32 @main.divUint(i32 %x, i32 %y, ptr %context) unnamed_addr #2 {
+define hidden i32 @main.divUint(i32 %x, i32 %y, ptr %context) unnamed_addr #1 {
 entry:
   %0 = icmp eq i32 %y, 0
   br i1 %0, label %divbyzero.throw, label %divbyzero.next
@@ -67,12 +64,12 @@ divbyzero.next:                                   ; preds = %entry
   ret i32 %1
 
 divbyzero.throw:                                  ; preds = %entry
-  call void @runtime.divideByZeroPanic(ptr undef) #3
+  call void @runtime.divideByZeroPanic(ptr undef) #2
   unreachable
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.remInt(i32 %x, i32 %y, ptr %context) unnamed_addr #2 {
+define hidden i32 @main.remInt(i32 %x, i32 %y, ptr %context) unnamed_addr #1 {
 entry:
   %0 = icmp eq i32 %y, 0
   br i1 %0, label %divbyzero.throw, label %divbyzero.next
@@ -86,12 +83,12 @@ divbyzero.next:                                   ; preds = %entry
   ret i32 %5
 
 divbyzero.throw:                                  ; preds = %entry
-  call void @runtime.divideByZeroPanic(ptr undef) #3
+  call void @runtime.divideByZeroPanic(ptr undef) #2
   unreachable
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.remUint(i32 %x, i32 %y, ptr %context) unnamed_addr #2 {
+define hidden i32 @main.remUint(i32 %x, i32 %y, ptr %context) unnamed_addr #1 {
 entry:
   %0 = icmp eq i32 %y, 0
   br i1 %0, label %divbyzero.throw, label %divbyzero.next
@@ -101,66 +98,66 @@ divbyzero.next:                                   ; preds = %entry
   ret i32 %1
 
 divbyzero.throw:                                  ; preds = %entry
-  call void @runtime.divideByZeroPanic(ptr undef) #3
+  call void @runtime.divideByZeroPanic(ptr undef) #2
   unreachable
 }
 
 ; Function Attrs: nounwind
-define hidden i1 @main.floatEQ(float %x, float %y, ptr %context) unnamed_addr #2 {
+define hidden i1 @main.floatEQ(float %x, float %y, ptr %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, ptr %context) unnamed_addr #2 {
+define hidden i1 @main.floatNE(float %x, float %y, ptr %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, ptr %context) unnamed_addr #2 {
+define hidden i1 @main.floatLower(float %x, float %y, ptr %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, ptr %context) unnamed_addr #2 {
+define hidden i1 @main.floatLowerEqual(float %x, float %y, ptr %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, ptr %context) unnamed_addr #2 {
+define hidden i1 @main.floatGreater(float %x, float %y, ptr %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, ptr %context) unnamed_addr #2 {
+define hidden i1 @main.floatGreaterEqual(float %x, float %y, ptr %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, ptr %context) unnamed_addr #2 {
+define hidden float @main.complexReal(float %x.r, float %x.i, ptr %context) unnamed_addr #1 {
 entry:
   ret float %x.r
 }
 
 ; Function Attrs: nounwind
-define hidden float @main.complexImag(float %x.r, float %x.i, ptr %context) unnamed_addr #2 {
+define hidden float @main.complexImag(float %x.r, float %x.i, ptr %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, ptr %context) unnamed_addr #2 {
+define hidden { float, float } @main.complexAdd(float %x.r, float %x.i, float %y.r, float %y.i, ptr %context) unnamed_addr #1 {
 entry:
   %0 = fadd float %x.r, %y.r
   %1 = fadd float %x.i, %y.i
@@ -170,7 +167,7 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden { float, float } @main.complexSub(float %x.r, float %x.i, float %y.r, float %y.i, ptr %context) unnamed_addr #2 {
+define hidden { float, float } @main.complexSub(float %x.r, float %x.i, float %y.r, float %y.i, ptr %context) unnamed_addr #1 {
 entry:
   %0 = fsub float %x.r, %y.r
   %1 = fsub float %x.i, %y.i
@@ -180,7 +177,7 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden { float, float } @main.complexMul(float %x.r, float %x.i, float %y.r, float %y.i, ptr %context) unnamed_addr #2 {
+define hidden { float, float } @main.complexMul(float %x.r, float %x.i, float %y.r, float %y.i, ptr %context) unnamed_addr #1 {
 entry:
   %0 = fmul float %x.r, %y.r
   %1 = fmul float %x.i, %y.i
@@ -194,19 +191,18 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.foo(ptr %context) unnamed_addr #2 {
+define hidden void @main.foo(ptr %context) unnamed_addr #1 {
 entry:
   call void @"main.foo$1"(%main.kv.0 zeroinitializer, ptr undef)
   ret void
 }
 
 ; Function Attrs: nounwind
-define internal void @"main.foo$1"(%main.kv.0 %b, ptr %context) unnamed_addr #2 {
+define internal void @"main.foo$1"(%main.kv.0 %b, ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
 
-attributes #0 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #1 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #2 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #3 = { nounwind }
+attributes #0 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #1 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #2 = { nounwind }

compiler/testdata/channel.ll

@@ -6,76 +6,73 @@ target triple = "wasm32-unknown-wasi"
 %runtime.channelOp = type { ptr, ptr, i32, ptr }
 %runtime.chanSelectState = type { ptr, ptr }
 
-; Function Attrs: allockind("alloc,zeroed") allocsize(0)
-declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #0
-
-declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #1
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.init(ptr %context) unnamed_addr #2 {
+define hidden void @main.init(ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.chanIntSend(ptr dereferenceable_or_null(36) %ch, ptr %context) unnamed_addr #2 {
+define hidden void @main.chanIntSend(ptr dereferenceable_or_null(36) %ch, ptr %context) unnamed_addr #1 {
 entry:
   %chan.op = alloca %runtime.channelOp, align 8
   %chan.value = alloca i32, align 4
   call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %chan.value)
   store i32 3, ptr %chan.value, align 4
   call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %chan.op)
-  call void @runtime.chanSend(ptr %ch, ptr nonnull %chan.value, ptr nonnull %chan.op, ptr undef) #4
+  call void @runtime.chanSend(ptr %ch, ptr nonnull %chan.value, ptr nonnull %chan.op, ptr undef) #3
   call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %chan.op)
   call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %chan.value)
   ret void
 }
 
 ; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: readwrite)
-declare void @llvm.lifetime.start.p0(i64 immarg, ptr nocapture) #3
+declare void @llvm.lifetime.start.p0(i64 immarg, ptr nocapture) #2
 
-declare void @runtime.chanSend(ptr dereferenceable_or_null(36), ptr, ptr dereferenceable_or_null(16), ptr) #1
+declare void @runtime.chanSend(ptr dereferenceable_or_null(36), ptr, ptr dereferenceable_or_null(16), ptr) #0
 
 ; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: readwrite)
-declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #3
+declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #2
 
 ; Function Attrs: nounwind
-define hidden void @main.chanIntRecv(ptr dereferenceable_or_null(36) %ch, ptr %context) unnamed_addr #2 {
+define hidden void @main.chanIntRecv(ptr dereferenceable_or_null(36) %ch, ptr %context) unnamed_addr #1 {
 entry:
   %chan.op = alloca %runtime.channelOp, align 8
   %chan.value = alloca i32, align 4
   call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %chan.value)
   call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %chan.op)
-  %0 = call i1 @runtime.chanRecv(ptr %ch, ptr nonnull %chan.value, ptr nonnull %chan.op, ptr undef) #4
+  %0 = call i1 @runtime.chanRecv(ptr %ch, ptr nonnull %chan.value, ptr nonnull %chan.op, ptr undef) #3
   call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %chan.value)
   call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %chan.op)
   ret void
 }
 
-declare i1 @runtime.chanRecv(ptr dereferenceable_or_null(36), ptr, ptr dereferenceable_or_null(16), ptr) #1
+declare i1 @runtime.chanRecv(ptr dereferenceable_or_null(36), ptr, ptr dereferenceable_or_null(16), ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.chanZeroSend(ptr dereferenceable_or_null(36) %ch, ptr %context) unnamed_addr #2 {
+define hidden void @main.chanZeroSend(ptr dereferenceable_or_null(36) %ch, ptr %context) unnamed_addr #1 {
 entry:
   %chan.op = alloca %runtime.channelOp, align 8
   call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %chan.op)
-  call void @runtime.chanSend(ptr %ch, ptr null, ptr nonnull %chan.op, ptr undef) #4
+  call void @runtime.chanSend(ptr %ch, ptr null, ptr nonnull %chan.op, ptr undef) #3
   call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %chan.op)
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.chanZeroRecv(ptr dereferenceable_or_null(36) %ch, ptr %context) unnamed_addr #2 {
+define hidden void @main.chanZeroRecv(ptr dereferenceable_or_null(36) %ch, ptr %context) unnamed_addr #1 {
 entry:
   %chan.op = alloca %runtime.channelOp, align 8
   call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %chan.op)
-  %0 = call i1 @runtime.chanRecv(ptr %ch, ptr null, ptr nonnull %chan.op, ptr undef) #4
+  %0 = call i1 @runtime.chanRecv(ptr %ch, ptr null, ptr nonnull %chan.op, ptr undef) #3
   call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %chan.op)
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.selectZeroRecv(ptr dereferenceable_or_null(36) %ch1, ptr dereferenceable_or_null(36) %ch2, ptr %context) unnamed_addr #2 {
+define hidden void @main.selectZeroRecv(ptr dereferenceable_or_null(36) %ch1, ptr dereferenceable_or_null(36) %ch2, ptr %context) unnamed_addr #1 {
 entry:
   %select.states.alloca = alloca [2 x %runtime.chanSelectState], align 8
   %select.send.value = alloca i32, align 4
@@ -88,7 +85,7 @@ entry:
   store ptr %ch2, ptr %0, align 4
   %.repack3 = getelementptr inbounds nuw i8, ptr %select.states.alloca, i32 12
   store ptr null, ptr %.repack3, align 4
-  %select.result = call { i32, i1 } @runtime.chanSelect(ptr undef, ptr nonnull %select.states.alloca, i32 2, i32 2, ptr null, i32 0, i32 0, ptr undef) #4
+  %select.result = call { i32, i1 } @runtime.chanSelect(ptr undef, ptr nonnull %select.states.alloca, i32 2, i32 2, ptr null, i32 0, i32 0, ptr undef) #3
   call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %select.states.alloca)
   %1 = extractvalue { i32, i1 } %select.result, 0
   %2 = icmp eq i32 %1, 0
@@ -105,10 +102,9 @@ select.body:                                      ; preds = %select.next
   br label %select.done
 }
 
-declare { i32, i1 } @runtime.chanSelect(ptr, ptr, i32, i32, ptr, i32, i32, ptr) #1
+declare { i32, i1 } @runtime.chanSelect(ptr, ptr, i32, i32, ptr, i32, i32, ptr) #0
 
-attributes #0 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #1 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #2 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #3 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
-attributes #4 = { nounwind }
+attributes #0 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #1 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #2 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
+attributes #3 = { nounwind }

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

@@ -6,19 +6,16 @@ target triple = "thumbv7m-unknown-unknown-eabi"
 %runtime.deferFrame = type { ptr, ptr, [0 x ptr], ptr, i8, %runtime._interface }
 %runtime._interface = type { ptr, ptr }
 
-; Function Attrs: allockind("alloc,zeroed") allocsize(0)
-declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #0
-
 ; Function Attrs: nounwind
-define hidden void @main.init(ptr %context) unnamed_addr #1 {
+define hidden void @main.init(ptr %context) unnamed_addr #0 {
 entry:
   ret void
 }
 
-declare void @main.external(ptr) #2
+declare void @main.external(ptr) #1
 
 ; Function Attrs: nounwind
-define hidden void @main.deferSimple(ptr %context) unnamed_addr #1 {
+define hidden void @main.deferSimple(ptr %context) unnamed_addr #0 {
 entry:
   %defer.alloca = alloca { i32, ptr }, align 4
   %deferPtr = alloca ptr, align 4
@@ -112,14 +109,14 @@ rundefers.end3:                                   ; preds = %rundefers.loophead6
 }
 
 ; Function Attrs: nocallback nofree nosync nounwind willreturn
-declare ptr @llvm.stacksave.p0() #3
+declare ptr @llvm.stacksave.p0() #2
 
-declare void @runtime.setupDeferFrame(ptr dereferenceable_or_null(24), ptr, ptr) #2
+declare void @runtime.setupDeferFrame(ptr dereferenceable_or_null(24), ptr, ptr) #1
 
-declare void @runtime.destroyDeferFrame(ptr dereferenceable_or_null(24), ptr) #2
+declare void @runtime.destroyDeferFrame(ptr dereferenceable_or_null(24), ptr) #1
 
 ; Function Attrs: nounwind
-define internal void @"main.deferSimple$1"(ptr %context) unnamed_addr #1 {
+define internal void @"main.deferSimple$1"(ptr %context) unnamed_addr #0 {
 entry:
   call void @runtime.printlock(ptr undef) #4
   call void @runtime.printint32(i32 3, ptr undef) #4
@@ -127,14 +124,14 @@ entry:
   ret void
 }
 
-declare void @runtime.printlock(ptr) #2
+declare void @runtime.printlock(ptr) #1
 
-declare void @runtime.printint32(i32, ptr) #2
+declare void @runtime.printint32(i32, ptr) #1
 
-declare void @runtime.printunlock(ptr) #2
+declare void @runtime.printunlock(ptr) #1
 
 ; Function Attrs: nounwind
-define hidden void @main.deferMultiple(ptr %context) unnamed_addr #1 {
+define hidden void @main.deferMultiple(ptr %context) unnamed_addr #0 {
 entry:
   %defer.alloca2 = alloca { i32, ptr }, align 4
   %defer.alloca = alloca { i32, ptr }, align 4
@@ -253,7 +250,7 @@ rundefers.end7:                                   ; preds = %rundefers.loophead1
 }
 
 ; Function Attrs: nounwind
-define internal void @"main.deferMultiple$1"(ptr %context) unnamed_addr #1 {
+define internal void @"main.deferMultiple$1"(ptr %context) unnamed_addr #0 {
 entry:
   call void @runtime.printlock(ptr undef) #4
   call void @runtime.printint32(i32 3, ptr undef) #4
@@ -262,7 +259,7 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define internal void @"main.deferMultiple$2"(ptr %context) unnamed_addr #1 {
+define internal void @"main.deferMultiple$2"(ptr %context) unnamed_addr #0 {
 entry:
   call void @runtime.printlock(ptr undef) #4
   call void @runtime.printint32(i32 5, ptr undef) #4
@@ -271,7 +268,7 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.deferInfiniteLoop(ptr %context) unnamed_addr #1 {
+define hidden void @main.deferInfiniteLoop(ptr %context) unnamed_addr #0 {
 entry:
   %deferPtr = alloca ptr, align 4
   store ptr null, ptr %deferPtr, align 4
@@ -315,8 +312,11 @@ rundefers.end:                                    ; preds = %rundefers.loophead
   br label %recover
 }
 
+; Function Attrs: allockind("alloc,zeroed") allocsize(0)
+declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #3
+
 ; Function Attrs: nounwind
-define hidden void @main.deferLoop(ptr %context) unnamed_addr #1 {
+define hidden void @main.deferLoop(ptr %context) unnamed_addr #0 {
 entry:
   %deferPtr = alloca ptr, align 4
   store ptr null, ptr %deferPtr, align 4
@@ -405,7 +405,7 @@ rundefers.end1:                                   ; preds = %rundefers.loophead4
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.deferBetweenLoops(ptr %context) unnamed_addr #1 {
+define hidden void @main.deferBetweenLoops(ptr %context) unnamed_addr #0 {
 entry:
   %defer.alloca = alloca { i32, ptr, i32 }, align 4
   %deferPtr = alloca ptr, align 4
@@ -505,9 +505,9 @@ rundefers.end4:                                   ; preds = %rundefers.loophead7
   br label %recover
 }
 
-attributes #0 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+armv7-m,+hwdiv,+soft-float,+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,+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 = { "target-features"="+armv7-m,+hwdiv,+soft-float,+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 #3 = { nocallback nofree nosync nounwind willreturn }
+attributes #0 = { nounwind "target-features"="+armv7-m,+hwdiv,+soft-float,+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 = { "target-features"="+armv7-m,+hwdiv,+soft-float,+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 = { nocallback nofree nosync nounwind willreturn }
+attributes #3 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+armv7-m,+hwdiv,+soft-float,+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 #4 = { nounwind }
 attributes #5 = { nounwind returns_twice }

compiler/testdata/float.ll

@@ -3,19 +3,16 @@ source_filename = "float.go"
 target datalayout = "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-i128:128-n32:64-S128-ni:1:10:20"
 target triple = "wasm32-unknown-wasi"
 
-; Function Attrs: allockind("alloc,zeroed") allocsize(0)
-declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #0
-
-declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #1
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.init(ptr %context) unnamed_addr #2 {
+define hidden void @main.init(ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.f32tou32(float %v, ptr %context) unnamed_addr #2 {
+define hidden i32 @main.f32tou32(float %v, ptr %context) unnamed_addr #1 {
 entry:
   %positive = fcmp oge float %v, 0.000000e+00
   %withinmax = fcmp ole float %v, 0x41EFFFFFC0000000
@@ -27,25 +24,25 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden float @main.maxu32f(ptr %context) unnamed_addr #2 {
+define hidden float @main.maxu32f(ptr %context) unnamed_addr #1 {
 entry:
   ret float 0x41F0000000000000
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.maxu32tof32(ptr %context) unnamed_addr #2 {
+define hidden i32 @main.maxu32tof32(ptr %context) unnamed_addr #1 {
 entry:
   ret i32 -1
 }
 
 ; Function Attrs: nounwind
-define hidden { i32, i32, i32, i32 } @main.inftoi32(ptr %context) unnamed_addr #2 {
+define hidden { i32, i32, i32, i32 } @main.inftoi32(ptr %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, ptr %context) unnamed_addr #2 {
+define hidden i32 @main.u32tof32tou32(i32 %v, ptr %context) unnamed_addr #1 {
 entry:
   %0 = uitofp i32 %v to float
   %withinmax = fcmp ole float %0, 0x41EFFFFFC0000000
@@ -55,7 +52,7 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden float @main.f32tou32tof32(float %v, ptr %context) unnamed_addr #2 {
+define hidden float @main.f32tou32tof32(float %v, ptr %context) unnamed_addr #1 {
 entry:
   %positive = fcmp oge float %v, 0.000000e+00
   %withinmax = fcmp ole float %v, 0x41EFFFFFC0000000
@@ -68,7 +65,7 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden i8 @main.f32tou8(float %v, ptr %context) unnamed_addr #2 {
+define hidden i8 @main.f32tou8(float %v, ptr %context) unnamed_addr #1 {
 entry:
   %positive = fcmp oge float %v, 0.000000e+00
   %withinmax = fcmp ole float %v, 2.550000e+02
@@ -80,7 +77,7 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden i8 @main.f32toi8(float %v, ptr %context) unnamed_addr #2 {
+define hidden i8 @main.f32toi8(float %v, ptr %context) unnamed_addr #1 {
 entry:
   %abovemin = fcmp oge float %v, -1.280000e+02
   %belowmax = fcmp ole float %v, 1.270000e+02
@@ -93,6 +90,5 @@ entry:
   ret i8 %0
 }
 
-attributes #0 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #1 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #2 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #0 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #1 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }

compiler/testdata/func.ll

@@ -3,48 +3,44 @@ source_filename = "func.go"
 target datalayout = "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-i128:128-n32:64-S128-ni:1:10:20"
 target triple = "wasm32-unknown-wasi"
 
-; Function Attrs: allockind("alloc,zeroed") allocsize(0)
-declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #0
-
-declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #1
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.init(ptr %context) unnamed_addr #2 {
+define hidden void @main.init(ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.foo(ptr %callback.context, ptr %callback.funcptr, ptr %context) unnamed_addr #2 {
+define hidden void @main.foo(ptr %callback.context, ptr %callback.funcptr, ptr %context) unnamed_addr #1 {
 entry:
   %0 = icmp eq ptr %callback.funcptr, null
   br i1 %0, label %fpcall.throw, label %fpcall.next
 
 fpcall.next:                                      ; preds = %entry
-  call void %callback.funcptr(i32 3, ptr %callback.context) #3
+  call void %callback.funcptr(i32 3, ptr %callback.context) #2
   ret void
 
 fpcall.throw:                                     ; preds = %entry
-  call void @runtime.nilPanic(ptr undef) #3
+  call void @runtime.nilPanic(ptr undef) #2
   unreachable
 }
 
-declare void @runtime.nilPanic(ptr) #1
+declare void @runtime.nilPanic(ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.bar(ptr %context) unnamed_addr #2 {
+define hidden void @main.bar(ptr %context) unnamed_addr #1 {
 entry:
   call void @main.foo(ptr undef, ptr nonnull @main.someFunc, ptr undef)
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.someFunc(i32 %arg0, ptr %context) unnamed_addr #2 {
+define hidden void @main.someFunc(i32 %arg0, ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
 
-attributes #0 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #1 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #2 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #3 = { nounwind }
+attributes #0 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #1 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #2 = { nounwind }

compiler/testdata/gc.go

@@ -24,6 +24,10 @@ var (
 		x *byte
 		y [61]uintptr
 	}
+	struct5 *struct {
+		x *byte
+		y [30]uintptr
+	}
 
 	slice1 []byte
 	slice2 []*int
@@ -58,6 +62,10 @@ func newStruct() {
 		x *byte
 		y [61]uintptr
 	})
+	struct5 = new(struct {
+		x *byte
+		y [30]uintptr
+	})
 }
 
 func newFuncValue() *func() {

compiler/testdata/gc.ll

@@ -16,27 +16,25 @@ target triple = "wasm32-unknown-wasi"
 @main.struct2 = hidden global ptr null, align 4
 @main.struct3 = hidden global ptr null, align 4
 @main.struct4 = hidden global ptr null, align 4
+@main.struct5 = hidden global ptr null, align 4
 @main.slice1 = hidden global { ptr, i32, i32 } zeroinitializer, align 4
 @main.slice2 = hidden global { ptr, i32, i32 } zeroinitializer, align 4
 @main.slice3 = hidden global { ptr, i32, i32 } zeroinitializer, align 4
-@"runtime/gc.layout:62-2000000000000001" = linkonce_odr unnamed_addr constant { i32, [8 x i8] } { i32 62, [8 x i8] c"\01\00\00\00\00\00\00 " }
-@"runtime/gc.layout:62-0001" = linkonce_odr unnamed_addr constant { i32, [8 x i8] } { i32 62, [8 x i8] c"\01\00\00\00\00\00\00\00" }
+@"runtime/gc.layout:62-0100000000000020" = linkonce_odr unnamed_addr constant { i32, [8 x i8] } { i32 62, [8 x i8] c"\01\00\00\00\00\00\00 " }
+@"runtime/gc.layout:62-0100000000000000" = linkonce_odr unnamed_addr constant { i32, [8 x i8] } { i32 62, [8 x i8] c"\01\00\00\00\00\00\00\00" }
 @"reflect/types.type:basic:complex128" = linkonce_odr constant { i8, ptr } { i8 80, ptr @"reflect/types.type:pointer:basic:complex128" }, align 4
 @"reflect/types.type:pointer:basic:complex128" = linkonce_odr constant { i8, i16, ptr } { i8 -43, i16 0, ptr @"reflect/types.type:basic:complex128" }, align 4
 
-; Function Attrs: allockind("alloc,zeroed") allocsize(0)
-declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #0
-
-declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #1
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.init(ptr %context) unnamed_addr #2 {
+define hidden void @main.init(ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.newScalar(ptr %context) unnamed_addr #2 {
+define hidden void @main.newScalar(ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
   %new = call align 1 dereferenceable(1) ptr @runtime.alloc(i32 1, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
@@ -54,8 +52,11 @@ entry:
   ret void
 }
 
+; Function Attrs: allockind("alloc,zeroed") allocsize(0)
+declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #2
+
 ; Function Attrs: nounwind
-define hidden void @main.newArray(ptr %context) unnamed_addr #2 {
+define hidden void @main.newArray(ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
   %new = call align 1 dereferenceable(3) ptr @runtime.alloc(i32 3, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
@@ -71,7 +72,7 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.newStruct(ptr %context) unnamed_addr #2 {
+define hidden void @main.newStruct(ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
   %new = call align 1 ptr @runtime.alloc(i32 0, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
@@ -80,17 +81,20 @@ entry:
   %new1 = call align 4 dereferenceable(8) ptr @runtime.alloc(i32 8, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
   call void @runtime.trackPointer(ptr nonnull %new1, ptr nonnull %stackalloc, ptr undef) #3
   store ptr %new1, ptr @main.struct2, align 4
-  %new2 = call align 4 dereferenceable(248) ptr @runtime.alloc(i32 248, ptr nonnull @"runtime/gc.layout:62-2000000000000001", ptr undef) #3
+  %new2 = call align 4 dereferenceable(248) ptr @runtime.alloc(i32 248, ptr nonnull @"runtime/gc.layout:62-0100000000000020", ptr undef) #3
   call void @runtime.trackPointer(ptr nonnull %new2, ptr nonnull %stackalloc, ptr undef) #3
   store ptr %new2, ptr @main.struct3, align 4
-  %new3 = call align 4 dereferenceable(248) ptr @runtime.alloc(i32 248, ptr nonnull @"runtime/gc.layout:62-0001", ptr undef) #3
+  %new3 = call align 4 dereferenceable(248) ptr @runtime.alloc(i32 248, ptr nonnull @"runtime/gc.layout:62-0100000000000000", ptr undef) #3
   call void @runtime.trackPointer(ptr nonnull %new3, ptr nonnull %stackalloc, ptr undef) #3
   store ptr %new3, ptr @main.struct4, align 4
+  %new4 = call align 4 dereferenceable(124) ptr @runtime.alloc(i32 124, ptr nonnull inttoptr (i32 127 to ptr), ptr undef) #3
+  call void @runtime.trackPointer(ptr nonnull %new4, ptr nonnull %stackalloc, ptr undef) #3
+  store ptr %new4, ptr @main.struct5, align 4
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden ptr @main.newFuncValue(ptr %context) unnamed_addr #2 {
+define hidden ptr @main.newFuncValue(ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
   %new = call align 4 dereferenceable(8) ptr @runtime.alloc(i32 8, ptr nonnull inttoptr (i32 197 to ptr), ptr undef) #3
@@ -99,7 +103,7 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.makeSlice(ptr %context) unnamed_addr #2 {
+define hidden void @main.makeSlice(ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
   %makeslice = call align 1 dereferenceable(5) ptr @runtime.alloc(i32 5, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
@@ -121,7 +125,7 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden %runtime._interface @main.makeInterface(double %v.r, double %v.i, ptr %context) unnamed_addr #2 {
+define hidden %runtime._interface @main.makeInterface(double %v.r, double %v.i, ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
   %0 = call align 8 dereferenceable(16) ptr @runtime.alloc(i32 16, ptr null, ptr undef) #3
@@ -135,7 +139,7 @@ entry:
   ret %runtime._interface %1
 }
 
-attributes #0 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #1 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #2 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #0 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #1 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #2 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
 attributes #3 = { nounwind }

compiler/testdata/generics.ll

@@ -1,144 +1,78 @@
 ; 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 datalayout = "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-i128:128-n32:64-S128-ni:1:10:20"
 target triple = "wasm32-unknown-wasi"
 
-%"main.Point[int]" = type { i32, i32 }
 %"main.Point[float32]" = type { float, float }
+%"main.Point[int]" = type { i32, i32 }
 
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*) #0
-
-declare void @runtime.trackPointer(i8* nocapture readonly, i8*) #0
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.init(i8* %context) unnamed_addr #1 {
+define hidden void @main.init(ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.main(i8* %context) unnamed_addr #1 {
+define hidden void @main.main(ptr %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)
+  %0 = call %"main.Point[float32]" @"main.Add[float32]"(float 0.000000e+00, float 0.000000e+00, float 0.000000e+00, float 0.000000e+00, ptr undef)
+  %1 = call %"main.Point[int]" @"main.Add[int]"(i32 0, i32 0, i32 0, i32 0, ptr 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 {
+define linkonce_odr hidden %"main.Point[float32]" @"main.Add[float32]"(float %a.X, float %a.Y, float %b.X, float %b.Y, ptr %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
+  %stackalloc = alloca i8, align 1
+  %a = call align 4 dereferenceable(8) ptr @runtime.alloc(i32 8, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
+  call void @runtime.trackPointer(ptr nonnull %a, ptr nonnull %stackalloc, ptr undef) #3
+  store float %a.X, ptr %a, align 4
+  %a.repack9 = getelementptr inbounds nuw i8, ptr %a, i32 4
+  store float %a.Y, ptr %a.repack9, align 4
+  %b = call align 4 dereferenceable(8) ptr @runtime.alloc(i32 8, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
+  call void @runtime.trackPointer(ptr nonnull %b, ptr nonnull %stackalloc, ptr undef) #3
+  store float %b.X, ptr %b, align 4
+  %b.repack11 = getelementptr inbounds nuw i8, ptr %b, i32 4
+  store float %b.Y, ptr %b.repack11, align 4
+  call void @main.checkSize(i32 4, ptr undef) #3
+  call void @main.checkSize(i32 8, ptr undef) #3
+  %complit = call align 4 dereferenceable(8) ptr @runtime.alloc(i32 8, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
+  call void @runtime.trackPointer(ptr nonnull %complit, ptr nonnull %stackalloc, ptr undef) #3
   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
+  %0 = load float, ptr %a, align 4
+  %1 = load float, ptr %b, align 4
+  %2 = fadd float %0, %1
   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
+  %3 = getelementptr inbounds nuw i8, ptr %b, i32 4
+  %4 = getelementptr inbounds nuw i8, ptr %a, i32 4
+  %5 = load float, ptr %4, align 4
+  %6 = load float, ptr %3, align 4
   br i1 false, label %store.throw, label %store.next
 
 store.next:                                       ; preds = %deref.next6
-  store float %8, float* %3, align 8
+  store float %2, ptr %complit, align 4
   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
+  %7 = getelementptr inbounds nuw i8, ptr %complit, i32 4
+  %8 = fadd float %5, %6
+  store float %8, ptr %7, align 4
+  %.unpack = load float, ptr %complit, align 4
+  %9 = insertvalue %"main.Point[float32]" poison, float %.unpack, 0
+  %10 = insertvalue %"main.Point[float32]" %9, float %8, 1
+  ret %"main.Point[float32]" %10
 
 deref.throw:                                      ; preds = %entry
   unreachable
@@ -159,81 +93,64 @@ store.throw7:                                     ; preds = %store.next
   unreachable
 }
 
-declare void @main.checkSize(i32, i8*) #0
+; Function Attrs: allockind("alloc,zeroed") allocsize(0)
+declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #2
 
-declare void @runtime.nilPanic(i8*) #0
+declare void @main.checkSize(i32, ptr) #0
+
+declare void @runtime.nilPanic(ptr) #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 {
+define linkonce_odr hidden %"main.Point[int]" @"main.Add[int]"(i32 %a.X, i32 %a.Y, i32 %b.X, i32 %b.Y, ptr %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
+  %stackalloc = alloca i8, align 1
+  %a = call align 4 dereferenceable(8) ptr @runtime.alloc(i32 8, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
+  call void @runtime.trackPointer(ptr nonnull %a, ptr nonnull %stackalloc, ptr undef) #3
+  store i32 %a.X, ptr %a, align 4
+  %a.repack9 = getelementptr inbounds nuw i8, ptr %a, i32 4
+  store i32 %a.Y, ptr %a.repack9, align 4
+  %b = call align 4 dereferenceable(8) ptr @runtime.alloc(i32 8, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
+  call void @runtime.trackPointer(ptr nonnull %b, ptr nonnull %stackalloc, ptr undef) #3
+  store i32 %b.X, ptr %b, align 4
+  %b.repack11 = getelementptr inbounds nuw i8, ptr %b, i32 4
+  store i32 %b.Y, ptr %b.repack11, align 4
+  call void @main.checkSize(i32 4, ptr undef) #3
+  call void @main.checkSize(i32 8, ptr undef) #3
+  %complit = call align 4 dereferenceable(8) ptr @runtime.alloc(i32 8, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
+  call void @runtime.trackPointer(ptr nonnull %complit, ptr nonnull %stackalloc, ptr undef) #3
   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
+  %0 = load i32, ptr %a, align 4
+  %1 = load i32, ptr %b, align 4
+  %2 = add i32 %0, %1
   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
+  %3 = getelementptr inbounds nuw i8, ptr %b, i32 4
+  %4 = getelementptr inbounds nuw i8, ptr %a, i32 4
+  %5 = load i32, ptr %4, align 4
+  %6 = load i32, ptr %3, align 4
   br i1 false, label %store.throw, label %store.next
 
 store.next:                                       ; preds = %deref.next6
-  store i32 %8, i32* %3, align 8
+  store i32 %2, ptr %complit, align 4
   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
+  %7 = getelementptr inbounds nuw i8, ptr %complit, i32 4
+  %8 = add i32 %5, %6
+  store i32 %8, ptr %7, align 4
+  %.unpack = load i32, ptr %complit, align 4
+  %9 = insertvalue %"main.Point[int]" poison, i32 %.unpack, 0
+  %10 = insertvalue %"main.Point[int]" %9, i32 %8, 1
+  ret %"main.Point[int]" %10
 
 deref.throw:                                      ; preds = %entry
   unreachable
@@ -254,6 +171,7 @@ 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 }
+attributes #0 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #1 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #2 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #3 = { nounwind }

compiler/testdata/go1.20.ll

@@ -5,27 +5,24 @@ target triple = "wasm32-unknown-wasi"
 
 %runtime._string = type { ptr, i32 }
 
-; Function Attrs: allockind("alloc,zeroed") allocsize(0)
-declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #0
-
-declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #1
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.init(ptr %context) unnamed_addr #2 {
+define hidden void @main.init(ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden ptr @main.unsafeSliceData(ptr %s.data, i32 %s.len, i32 %s.cap, ptr %context) unnamed_addr #2 {
+define hidden ptr @main.unsafeSliceData(ptr %s.data, i32 %s.len, i32 %s.cap, ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
-  call void @runtime.trackPointer(ptr %s.data, ptr nonnull %stackalloc, ptr undef) #3
+  call void @runtime.trackPointer(ptr %s.data, ptr nonnull %stackalloc, ptr undef) #2
   ret ptr %s.data
 }
 
 ; Function Attrs: nounwind
-define hidden %runtime._string @main.unsafeString(ptr dereferenceable_or_null(1) %ptr, i16 %len, ptr %context) unnamed_addr #2 {
+define hidden %runtime._string @main.unsafeString(ptr dereferenceable_or_null(1) %ptr, i16 %len, ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
   %0 = icmp slt i16 %len, 0
@@ -39,25 +36,24 @@ unsafe.String.next:                               ; preds = %entry
   %5 = zext nneg i16 %len to i32
   %6 = insertvalue %runtime._string undef, ptr %ptr, 0
   %7 = insertvalue %runtime._string %6, i32 %5, 1
-  call void @runtime.trackPointer(ptr %ptr, ptr nonnull %stackalloc, ptr undef) #3
+  call void @runtime.trackPointer(ptr %ptr, ptr nonnull %stackalloc, ptr undef) #2
   ret %runtime._string %7
 
 unsafe.String.throw:                              ; preds = %entry
-  call void @runtime.unsafeSlicePanic(ptr undef) #3
+  call void @runtime.unsafeSlicePanic(ptr undef) #2
   unreachable
 }
 
-declare void @runtime.unsafeSlicePanic(ptr) #1
+declare void @runtime.unsafeSlicePanic(ptr) #0
 
 ; Function Attrs: nounwind
-define hidden ptr @main.unsafeStringData(ptr readonly %s.data, i32 %s.len, ptr %context) unnamed_addr #2 {
+define hidden ptr @main.unsafeStringData(ptr readonly %s.data, i32 %s.len, ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
-  call void @runtime.trackPointer(ptr %s.data, ptr nonnull %stackalloc, ptr undef) #3
+  call void @runtime.trackPointer(ptr %s.data, ptr nonnull %stackalloc, ptr undef) #2
   ret ptr %s.data
 }
 
-attributes #0 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #1 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #2 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #3 = { nounwind }
+attributes #0 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #1 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #2 = { nounwind }

compiler/testdata/go1.21.ll

@@ -5,35 +5,32 @@ target triple = "wasm32-unknown-wasi"
 
 %runtime._string = type { ptr, i32 }
 
-; Function Attrs: allockind("alloc,zeroed") allocsize(0)
-declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #0
-
-declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #1
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.init(ptr %context) unnamed_addr #2 {
+define hidden void @main.init(ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.min1(i32 %a, ptr %context) unnamed_addr #2 {
+define hidden i32 @main.min1(i32 %a, ptr %context) unnamed_addr #1 {
 entry:
   ret i32 %a
 }
 
 ; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
-declare i32 @llvm.smin.i32(i32, i32) #3
+declare i32 @llvm.smin.i32(i32, i32) #2
 
 ; Function Attrs: nounwind
-define hidden i32 @main.min2(i32 %a, i32 %b, ptr %context) unnamed_addr #2 {
+define hidden i32 @main.min2(i32 %a, i32 %b, ptr %context) unnamed_addr #1 {
 entry:
   %0 = call i32 @llvm.smin.i32(i32 %a, i32 %b)
   ret i32 %0
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.min3(i32 %a, i32 %b, i32 %c, ptr %context) unnamed_addr #2 {
+define hidden i32 @main.min3(i32 %a, i32 %b, i32 %c, ptr %context) unnamed_addr #1 {
 entry:
   %0 = call i32 @llvm.smin.i32(i32 %a, i32 %b)
   %1 = call i32 @llvm.smin.i32(i32 %0, i32 %c)
@@ -41,7 +38,7 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.min4(i32 %a, i32 %b, i32 %c, i32 %d, ptr %context) unnamed_addr #2 {
+define hidden i32 @main.min4(i32 %a, i32 %b, i32 %c, i32 %d, ptr %context) unnamed_addr #1 {
 entry:
   %0 = call i32 @llvm.smin.i32(i32 %a, i32 %b)
   %1 = call i32 @llvm.smin.i32(i32 %0, i32 %c)
@@ -50,109 +47,109 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden i8 @main.minUint8(i8 %a, i8 %b, ptr %context) unnamed_addr #2 {
+define hidden i8 @main.minUint8(i8 %a, i8 %b, ptr %context) unnamed_addr #1 {
 entry:
   %0 = call i8 @llvm.umin.i8(i8 %a, i8 %b)
   ret i8 %0
 }
 
 ; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
-declare i8 @llvm.umin.i8(i8, i8) #3
+declare i8 @llvm.umin.i8(i8, i8) #2
 
 ; Function Attrs: nounwind
-define hidden i32 @main.minUnsigned(i32 %a, i32 %b, ptr %context) unnamed_addr #2 {
+define hidden i32 @main.minUnsigned(i32 %a, i32 %b, ptr %context) unnamed_addr #1 {
 entry:
   %0 = call i32 @llvm.umin.i32(i32 %a, i32 %b)
   ret i32 %0
 }
 
 ; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
-declare i32 @llvm.umin.i32(i32, i32) #3
+declare i32 @llvm.umin.i32(i32, i32) #2
 
 ; Function Attrs: nounwind
-define hidden float @main.minFloat32(float %a, float %b, ptr %context) unnamed_addr #2 {
+define hidden float @main.minFloat32(float %a, float %b, ptr %context) unnamed_addr #1 {
 entry:
   %0 = call float @llvm.minimum.f32(float %a, float %b)
   ret float %0
 }
 
 ; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
-declare float @llvm.minimum.f32(float, float) #3
+declare float @llvm.minimum.f32(float, float) #2
 
 ; Function Attrs: nounwind
-define hidden double @main.minFloat64(double %a, double %b, ptr %context) unnamed_addr #2 {
+define hidden double @main.minFloat64(double %a, double %b, ptr %context) unnamed_addr #1 {
 entry:
   %0 = call double @llvm.minimum.f64(double %a, double %b)
   ret double %0
 }
 
 ; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
-declare double @llvm.minimum.f64(double, double) #3
+declare double @llvm.minimum.f64(double, double) #2
 
 ; Function Attrs: nounwind
-define hidden %runtime._string @main.minString(ptr readonly %a.data, i32 %a.len, ptr readonly %b.data, i32 %b.len, ptr %context) unnamed_addr #2 {
+define hidden %runtime._string @main.minString(ptr readonly %a.data, i32 %a.len, ptr readonly %b.data, i32 %b.len, ptr %context) unnamed_addr #1 {
 entry:
   %0 = insertvalue %runtime._string zeroinitializer, ptr %a.data, 0
   %1 = insertvalue %runtime._string %0, i32 %a.len, 1
   %2 = insertvalue %runtime._string zeroinitializer, ptr %b.data, 0
   %3 = insertvalue %runtime._string %2, i32 %b.len, 1
   %stackalloc = alloca i8, align 1
-  %4 = call i1 @runtime.stringLess(ptr %a.data, i32 %a.len, ptr %b.data, i32 %b.len, ptr undef) #5
+  %4 = call i1 @runtime.stringLess(ptr %a.data, i32 %a.len, ptr %b.data, i32 %b.len, ptr undef) #4
   %5 = select i1 %4, %runtime._string %1, %runtime._string %3
   %6 = select i1 %4, ptr %a.data, ptr %b.data
-  call void @runtime.trackPointer(ptr %6, ptr nonnull %stackalloc, ptr undef) #5
+  call void @runtime.trackPointer(ptr %6, ptr nonnull %stackalloc, ptr undef) #4
   ret %runtime._string %5
 }
 
-declare i1 @runtime.stringLess(ptr readonly, i32, ptr readonly, i32, ptr) #1
+declare i1 @runtime.stringLess(ptr readonly, i32, ptr readonly, i32, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden i32 @main.maxInt(i32 %a, i32 %b, ptr %context) unnamed_addr #2 {
+define hidden i32 @main.maxInt(i32 %a, i32 %b, ptr %context) unnamed_addr #1 {
 entry:
   %0 = call i32 @llvm.smax.i32(i32 %a, i32 %b)
   ret i32 %0
 }
 
 ; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
-declare i32 @llvm.smax.i32(i32, i32) #3
+declare i32 @llvm.smax.i32(i32, i32) #2
 
 ; Function Attrs: nounwind
-define hidden i32 @main.maxUint(i32 %a, i32 %b, ptr %context) unnamed_addr #2 {
+define hidden i32 @main.maxUint(i32 %a, i32 %b, ptr %context) unnamed_addr #1 {
 entry:
   %0 = call i32 @llvm.umax.i32(i32 %a, i32 %b)
   ret i32 %0
 }
 
 ; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
-declare i32 @llvm.umax.i32(i32, i32) #3
+declare i32 @llvm.umax.i32(i32, i32) #2
 
 ; Function Attrs: nounwind
-define hidden float @main.maxFloat32(float %a, float %b, ptr %context) unnamed_addr #2 {
+define hidden float @main.maxFloat32(float %a, float %b, ptr %context) unnamed_addr #1 {
 entry:
   %0 = call float @llvm.maximum.f32(float %a, float %b)
   ret float %0
 }
 
 ; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
-declare float @llvm.maximum.f32(float, float) #3
+declare float @llvm.maximum.f32(float, float) #2
 
 ; Function Attrs: nounwind
-define hidden %runtime._string @main.maxString(ptr readonly %a.data, i32 %a.len, ptr readonly %b.data, i32 %b.len, ptr %context) unnamed_addr #2 {
+define hidden %runtime._string @main.maxString(ptr readonly %a.data, i32 %a.len, ptr readonly %b.data, i32 %b.len, ptr %context) unnamed_addr #1 {
 entry:
   %0 = insertvalue %runtime._string zeroinitializer, ptr %a.data, 0
   %1 = insertvalue %runtime._string %0, i32 %a.len, 1
   %2 = insertvalue %runtime._string zeroinitializer, ptr %b.data, 0
   %3 = insertvalue %runtime._string %2, i32 %b.len, 1
   %stackalloc = alloca i8, align 1
-  %4 = call i1 @runtime.stringLess(ptr %b.data, i32 %b.len, ptr %a.data, i32 %a.len, ptr undef) #5
+  %4 = call i1 @runtime.stringLess(ptr %b.data, i32 %b.len, ptr %a.data, i32 %a.len, ptr undef) #4
   %5 = select i1 %4, %runtime._string %1, %runtime._string %3
   %6 = select i1 %4, ptr %a.data, ptr %b.data
-  call void @runtime.trackPointer(ptr %6, ptr nonnull %stackalloc, ptr undef) #5
+  call void @runtime.trackPointer(ptr %6, ptr nonnull %stackalloc, ptr undef) #4
   ret %runtime._string %5
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.clearSlice(ptr %s.data, i32 %s.len, i32 %s.cap, ptr %context) unnamed_addr #2 {
+define hidden void @main.clearSlice(ptr %s.data, i32 %s.len, i32 %s.cap, ptr %context) unnamed_addr #1 {
 entry:
   %0 = shl i32 %s.len, 2
   call void @llvm.memset.p0.i32(ptr align 4 %s.data, i8 0, i32 %0, i1 false)
@@ -160,26 +157,25 @@ entry:
 }
 
 ; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: write)
-declare void @llvm.memset.p0.i32(ptr nocapture writeonly, i8, i32, i1 immarg) #4
+declare void @llvm.memset.p0.i32(ptr nocapture writeonly, i8, i32, i1 immarg) #3
 
 ; Function Attrs: nounwind
-define hidden void @main.clearZeroSizedSlice(ptr %s.data, i32 %s.len, i32 %s.cap, ptr %context) unnamed_addr #2 {
+define hidden void @main.clearZeroSizedSlice(ptr %s.data, i32 %s.len, i32 %s.cap, ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.clearMap(ptr dereferenceable_or_null(40) %m, ptr %context) unnamed_addr #2 {
+define hidden void @main.clearMap(ptr dereferenceable_or_null(48) %m, ptr %context) unnamed_addr #1 {
 entry:
-  call void @runtime.hashmapClear(ptr %m, ptr undef) #5
+  call void @runtime.hashmapClear(ptr %m, ptr undef) #4
   ret void
 }
 
-declare void @runtime.hashmapClear(ptr dereferenceable_or_null(40), ptr) #1
+declare void @runtime.hashmapClear(ptr dereferenceable_or_null(48), ptr) #0
 
-attributes #0 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #1 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #2 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #3 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
-attributes #4 = { nocallback nofree nounwind willreturn memory(argmem: write) }
-attributes #5 = { nounwind }
+attributes #0 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #1 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #2 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
+attributes #3 = { nocallback nofree nounwind willreturn memory(argmem: write) }
+attributes #4 = { nounwind }

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

@@ -5,39 +5,36 @@ target triple = "thumbv7m-unknown-unknown-eabi"
 
 @"main$string" = internal unnamed_addr constant [4 x i8] c"test", align 1
 
-; Function Attrs: allockind("alloc,zeroed") allocsize(0)
-declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #0
-
 ; Function Attrs: nounwind
-define hidden void @main.init(ptr %context) unnamed_addr #1 {
+define hidden void @main.init(ptr %context) unnamed_addr #0 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.regularFunctionGoroutine(ptr %context) unnamed_addr #1 {
+define hidden void @main.regularFunctionGoroutine(ptr %context) unnamed_addr #0 {
 entry:
   %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (ptr @"main.regularFunction$gowrapper" to i32), ptr undef) #11
   call void @"internal/task.start"(i32 ptrtoint (ptr @"main.regularFunction$gowrapper" to i32), ptr nonnull inttoptr (i32 5 to ptr), i32 %stacksize, ptr undef) #11
   ret void
 }
 
-declare void @main.regularFunction(i32, ptr) #2
+declare void @main.regularFunction(i32, ptr) #1
 
 ; Function Attrs: nounwind
-define linkonce_odr void @"main.regularFunction$gowrapper"(ptr %0) unnamed_addr #3 {
+define linkonce_odr void @"main.regularFunction$gowrapper"(ptr %0) unnamed_addr #2 {
 entry:
   %unpack.int = ptrtoint ptr %0 to i32
   call void @main.regularFunction(i32 %unpack.int, ptr undef) #11
   ret void
 }
 
-declare i32 @"internal/task.getGoroutineStackSize"(i32, ptr) #2
+declare i32 @"internal/task.getGoroutineStackSize"(i32, ptr) #1
 
-declare void @"internal/task.start"(i32, ptr, i32, ptr) #2
+declare void @"internal/task.start"(i32, ptr, i32, ptr) #1
 
 ; Function Attrs: nounwind
-define hidden void @main.inlineFunctionGoroutine(ptr %context) unnamed_addr #1 {
+define hidden void @main.inlineFunctionGoroutine(ptr %context) unnamed_addr #0 {
 entry:
   %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (ptr @"main.inlineFunctionGoroutine$1$gowrapper" to i32), ptr undef) #11
   call void @"internal/task.start"(i32 ptrtoint (ptr @"main.inlineFunctionGoroutine$1$gowrapper" to i32), ptr nonnull inttoptr (i32 5 to ptr), i32 %stacksize, ptr undef) #11
@@ -45,13 +42,13 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define internal void @"main.inlineFunctionGoroutine$1"(i32 %x, ptr %context) unnamed_addr #1 {
+define internal void @"main.inlineFunctionGoroutine$1"(i32 %x, ptr %context) unnamed_addr #0 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define linkonce_odr void @"main.inlineFunctionGoroutine$1$gowrapper"(ptr %0) unnamed_addr #4 {
+define linkonce_odr void @"main.inlineFunctionGoroutine$1$gowrapper"(ptr %0) unnamed_addr #3 {
 entry:
   %unpack.int = ptrtoint ptr %0 to i32
   call void @"main.inlineFunctionGoroutine$1"(i32 %unpack.int, ptr undef)
@@ -59,7 +56,7 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.closureFunctionGoroutine(ptr %context) unnamed_addr #1 {
+define hidden void @main.closureFunctionGoroutine(ptr %context) unnamed_addr #0 {
 entry:
   %n = call align 4 dereferenceable(4) ptr @runtime.alloc(i32 4, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #11
   store i32 3, ptr %n, align 4
@@ -76,8 +73,11 @@ entry:
   ret void
 }
 
+; Function Attrs: allockind("alloc,zeroed") allocsize(0)
+declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #4
+
 ; Function Attrs: nounwind
-define internal void @"main.closureFunctionGoroutine$1"(i32 %x, ptr %context) unnamed_addr #1 {
+define internal void @"main.closureFunctionGoroutine$1"(i32 %x, ptr %context) unnamed_addr #0 {
 entry:
   store i32 7, ptr %context, align 4
   ret void
@@ -93,14 +93,14 @@ entry:
   ret void
 }
 
-declare void @runtime.printlock(ptr) #2
+declare void @runtime.printlock(ptr) #1
 
-declare void @runtime.printint32(i32, ptr) #2
+declare void @runtime.printint32(i32, ptr) #1
 
-declare void @runtime.printunlock(ptr) #2
+declare void @runtime.printunlock(ptr) #1
 
 ; Function Attrs: nounwind
-define hidden void @main.funcGoroutine(ptr %fn.context, ptr %fn.funcptr, ptr %context) unnamed_addr #1 {
+define hidden void @main.funcGoroutine(ptr %fn.context, ptr %fn.funcptr, ptr %context) unnamed_addr #0 {
 entry:
   %0 = call align 4 dereferenceable(12) ptr @runtime.alloc(i32 12, ptr null, ptr undef) #11
   store i32 5, ptr %0, align 4
@@ -126,13 +126,13 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.recoverBuiltinGoroutine(ptr %context) unnamed_addr #1 {
+define hidden void @main.recoverBuiltinGoroutine(ptr %context) unnamed_addr #0 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.copyBuiltinGoroutine(ptr %dst.data, i32 %dst.len, i32 %dst.cap, ptr %src.data, i32 %src.len, i32 %src.cap, ptr %context) unnamed_addr #1 {
+define hidden void @main.copyBuiltinGoroutine(ptr %dst.data, i32 %dst.len, i32 %dst.cap, ptr %src.data, i32 %src.len, i32 %src.cap, ptr %context) unnamed_addr #0 {
 entry:
   %copy.n = call i32 @llvm.umin.i32(i32 %dst.len, i32 %src.len)
   call void @llvm.memmove.p0.p0.i32(ptr align 1 %dst.data, ptr align 1 %src.data, i32 %copy.n, i1 false)
@@ -146,16 +146,16 @@ declare i32 @llvm.umin.i32(i32, i32) #7
 declare void @llvm.memmove.p0.p0.i32(ptr nocapture writeonly, ptr nocapture readonly, i32, i1 immarg) #8
 
 ; Function Attrs: nounwind
-define hidden void @main.closeBuiltinGoroutine(ptr dereferenceable_or_null(36) %ch, ptr %context) unnamed_addr #1 {
+define hidden void @main.closeBuiltinGoroutine(ptr dereferenceable_or_null(36) %ch, ptr %context) unnamed_addr #0 {
 entry:
   call void @runtime.chanClose(ptr %ch, ptr undef) #11
   ret void
 }
 
-declare void @runtime.chanClose(ptr dereferenceable_or_null(36), ptr) #2
+declare void @runtime.chanClose(ptr dereferenceable_or_null(36), ptr) #1
 
 ; Function Attrs: nounwind
-define hidden void @main.startInterfaceMethod(ptr %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
+define hidden void @main.startInterfaceMethod(ptr %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #0 {
 entry:
   %0 = call align 4 dereferenceable(16) ptr @runtime.alloc(i32 16, ptr null, ptr undef) #11
   store ptr %itf.value, ptr %0, align 4
@@ -186,11 +186,11 @@ entry:
   ret void
 }
 
-attributes #0 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+armv7-m,+hwdiv,+soft-float,+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,+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 = { "target-features"="+armv7-m,+hwdiv,+soft-float,+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 #3 = { nounwind "target-features"="+armv7-m,+hwdiv,+soft-float,+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 #4 = { nounwind "target-features"="+armv7-m,+hwdiv,+soft-float,+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 #0 = { nounwind "target-features"="+armv7-m,+hwdiv,+soft-float,+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 = { "target-features"="+armv7-m,+hwdiv,+soft-float,+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,+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,+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 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+armv7-m,+hwdiv,+soft-float,+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 #5 = { nounwind "target-features"="+armv7-m,+hwdiv,+soft-float,+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 #6 = { nounwind "target-features"="+armv7-m,+hwdiv,+soft-float,+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 #7 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }

compiler/testdata/goroutine-wasm-asyncify.ll

@@ -5,30 +5,27 @@ target triple = "wasm32-unknown-wasi"
 
 @"main$string" = internal unnamed_addr constant [4 x i8] c"test", align 1
 
-; Function Attrs: allockind("alloc,zeroed") allocsize(0)
-declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #0
-
-declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #1
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.init(ptr %context) unnamed_addr #2 {
+define hidden void @main.init(ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.regularFunctionGoroutine(ptr %context) unnamed_addr #2 {
+define hidden void @main.regularFunctionGoroutine(ptr %context) unnamed_addr #1 {
 entry:
   call void @"internal/task.start"(i32 ptrtoint (ptr @"main.regularFunction$gowrapper" to i32), ptr nonnull inttoptr (i32 5 to ptr), i32 65536, ptr undef) #11
   ret void
 }
 
-declare void @main.regularFunction(i32, ptr) #1
+declare void @main.regularFunction(i32, ptr) #0
 
-declare void @runtime.deadlock(ptr) #1
+declare void @runtime.deadlock(ptr) #0
 
 ; Function Attrs: nounwind
-define linkonce_odr void @"main.regularFunction$gowrapper"(ptr %0) unnamed_addr #3 {
+define linkonce_odr void @"main.regularFunction$gowrapper"(ptr %0) unnamed_addr #2 {
 entry:
   %unpack.int = ptrtoint ptr %0 to i32
   call void @main.regularFunction(i32 %unpack.int, ptr undef) #11
@@ -36,23 +33,23 @@ entry:
   unreachable
 }
 
-declare void @"internal/task.start"(i32, ptr, i32, ptr) #1
+declare void @"internal/task.start"(i32, ptr, i32, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.inlineFunctionGoroutine(ptr %context) unnamed_addr #2 {
+define hidden void @main.inlineFunctionGoroutine(ptr %context) unnamed_addr #1 {
 entry:
   call void @"internal/task.start"(i32 ptrtoint (ptr @"main.inlineFunctionGoroutine$1$gowrapper" to i32), ptr nonnull inttoptr (i32 5 to ptr), i32 65536, ptr undef) #11
   ret void
 }
 
 ; Function Attrs: nounwind
-define internal void @"main.inlineFunctionGoroutine$1"(i32 %x, ptr %context) unnamed_addr #2 {
+define internal void @"main.inlineFunctionGoroutine$1"(i32 %x, ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define linkonce_odr void @"main.inlineFunctionGoroutine$1$gowrapper"(ptr %0) unnamed_addr #4 {
+define linkonce_odr void @"main.inlineFunctionGoroutine$1$gowrapper"(ptr %0) unnamed_addr #3 {
 entry:
   %unpack.int = ptrtoint ptr %0 to i32
   call void @"main.inlineFunctionGoroutine$1"(i32 %unpack.int, ptr undef)
@@ -61,7 +58,7 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.closureFunctionGoroutine(ptr %context) unnamed_addr #2 {
+define hidden void @main.closureFunctionGoroutine(ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
   %n = call align 4 dereferenceable(4) ptr @runtime.alloc(i32 4, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #11
@@ -82,8 +79,11 @@ entry:
   ret void
 }
 
+; Function Attrs: allockind("alloc,zeroed") allocsize(0)
+declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #4
+
 ; Function Attrs: nounwind
-define internal void @"main.closureFunctionGoroutine$1"(i32 %x, ptr %context) unnamed_addr #2 {
+define internal void @"main.closureFunctionGoroutine$1"(i32 %x, ptr %context) unnamed_addr #1 {
 entry:
   store i32 7, ptr %context, align 4
   ret void
@@ -100,14 +100,14 @@ entry:
   unreachable
 }
 
-declare void @runtime.printlock(ptr) #1
+declare void @runtime.printlock(ptr) #0
 
-declare void @runtime.printint32(i32, ptr) #1
+declare void @runtime.printint32(i32, ptr) #0
 
-declare void @runtime.printunlock(ptr) #1
+declare void @runtime.printunlock(ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.funcGoroutine(ptr %fn.context, ptr %fn.funcptr, ptr %context) unnamed_addr #2 {
+define hidden void @main.funcGoroutine(ptr %fn.context, ptr %fn.funcptr, ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
   %0 = call align 4 dereferenceable(12) ptr @runtime.alloc(i32 12, ptr null, ptr undef) #11
@@ -135,13 +135,13 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.recoverBuiltinGoroutine(ptr %context) unnamed_addr #2 {
+define hidden void @main.recoverBuiltinGoroutine(ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.copyBuiltinGoroutine(ptr %dst.data, i32 %dst.len, i32 %dst.cap, ptr %src.data, i32 %src.len, i32 %src.cap, ptr %context) unnamed_addr #2 {
+define hidden void @main.copyBuiltinGoroutine(ptr %dst.data, i32 %dst.len, i32 %dst.cap, ptr %src.data, i32 %src.len, i32 %src.cap, ptr %context) unnamed_addr #1 {
 entry:
   %copy.n = call i32 @llvm.umin.i32(i32 %dst.len, i32 %src.len)
   call void @llvm.memmove.p0.p0.i32(ptr align 1 %dst.data, ptr align 1 %src.data, i32 %copy.n, i1 false)
@@ -155,16 +155,16 @@ declare i32 @llvm.umin.i32(i32, i32) #7
 declare void @llvm.memmove.p0.p0.i32(ptr nocapture writeonly, ptr nocapture readonly, i32, i1 immarg) #8
 
 ; Function Attrs: nounwind
-define hidden void @main.closeBuiltinGoroutine(ptr dereferenceable_or_null(36) %ch, ptr %context) unnamed_addr #2 {
+define hidden void @main.closeBuiltinGoroutine(ptr dereferenceable_or_null(36) %ch, ptr %context) unnamed_addr #1 {
 entry:
   call void @runtime.chanClose(ptr %ch, ptr undef) #11
   ret void
 }
 
-declare void @runtime.chanClose(ptr dereferenceable_or_null(36), ptr) #1
+declare void @runtime.chanClose(ptr dereferenceable_or_null(36), ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.startInterfaceMethod(ptr %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #2 {
+define hidden void @main.startInterfaceMethod(ptr %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
   %0 = call align 4 dereferenceable(16) ptr @runtime.alloc(i32 16, ptr null, ptr undef) #11
@@ -197,11 +197,11 @@ entry:
   unreachable
 }
 
-attributes #0 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #1 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #2 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #3 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" "tinygo-gowrapper"="main.regularFunction" }
-attributes #4 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" "tinygo-gowrapper"="main.inlineFunctionGoroutine$1" }
+attributes #0 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #1 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #2 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" "tinygo-gowrapper"="main.regularFunction" }
+attributes #3 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" "tinygo-gowrapper"="main.inlineFunctionGoroutine$1" }
+attributes #4 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
 attributes #5 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" "tinygo-gowrapper"="main.closureFunctionGoroutine$1" }
 attributes #6 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" "tinygo-gowrapper" }
 attributes #7 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }

compiler/testdata/interface.ll

@@ -9,65 +9,64 @@ target triple = "wasm32-unknown-wasi"
 @"reflect/types.type:basic:int" = linkonce_odr constant { i8, ptr } { i8 -62, ptr @"reflect/types.type:pointer:basic:int" }, align 4
 @"reflect/types.type:pointer:basic:int" = linkonce_odr constant { i8, i16, ptr } { i8 -43, i16 0, ptr @"reflect/types.type:basic:int" }, align 4
 @"reflect/types.type:pointer:named:error" = linkonce_odr constant { i8, i16, ptr } { i8 -43, i16 0, ptr @"reflect/types.type:named:error" }, align 4
-@"reflect/types.type:named:error" = linkonce_odr constant { i8, i16, ptr, ptr, ptr, [7 x i8] } { i8 116, i16 1, ptr @"reflect/types.type:pointer:named:error", ptr @"reflect/types.type:interface:{Error:func:{}{basic:string}}", ptr @"reflect/types.type.pkgpath.empty", [7 x i8] c".error\00" }, align 4
+@"reflect/types.signature:Error:func:{}{basic:string}" = linkonce_odr constant i8 0, align 1
+@"reflect/types.type:named:error" = linkonce_odr constant { i8, i16, ptr, ptr, ptr, { i32, [1 x ptr] }, [7 x i8] } { i8 116, i16 -32767, ptr @"reflect/types.type:pointer:named:error", ptr @"reflect/types.type:interface:{Error:func:{}{basic:string}}", ptr @"reflect/types.type.pkgpath.empty", { i32, [1 x ptr] } { i32 1, [1 x ptr] [ptr @"reflect/types.signature:Error:func:{}{basic:string}"] }, [7 x i8] c".error\00" }, align 4
 @"reflect/types.type.pkgpath.empty" = linkonce_odr unnamed_addr constant [1 x i8] zeroinitializer, align 1
-@"reflect/types.type:interface:{Error:func:{}{basic:string}}" = linkonce_odr constant { i8, ptr } { i8 84, ptr @"reflect/types.type:pointer:interface:{Error:func:{}{basic:string}}" }, align 4
+@"reflect/types.type:interface:{Error:func:{}{basic:string}}" = linkonce_odr constant { i8, ptr, { i32, [1 x ptr] } } { i8 84, ptr @"reflect/types.type:pointer:interface:{Error:func:{}{basic:string}}", { i32, [1 x ptr] } { i32 1, [1 x ptr] [ptr @"reflect/types.signature:Error:func:{}{basic:string}"] } }, align 4
 @"reflect/types.type:pointer:interface:{Error:func:{}{basic:string}}" = linkonce_odr constant { i8, i16, ptr } { i8 -43, i16 0, ptr @"reflect/types.type:interface:{Error:func:{}{basic:string}}" }, align 4
 @"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}" = linkonce_odr constant { i8, i16, ptr } { i8 -43, i16 0, ptr @"reflect/types.type:interface:{String:func:{}{basic:string}}" }, align 4
-@"reflect/types.type:interface:{String:func:{}{basic:string}}" = linkonce_odr constant { i8, ptr } { i8 84, ptr @"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}" }, align 4
+@"reflect/types.signature:String:func:{}{basic:string}" = linkonce_odr constant i8 0, align 1
+@"reflect/types.type:interface:{String:func:{}{basic:string}}" = linkonce_odr constant { i8, ptr, { i32, [1 x ptr] } } { i8 84, ptr @"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}", { i32, [1 x ptr] } { i32 1, [1 x ptr] [ptr @"reflect/types.signature:String:func:{}{basic:string}"] } }, align 4
 @"reflect/types.typeid:basic:int" = external constant i8
 
-; Function Attrs: allockind("alloc,zeroed") allocsize(0)
-declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #0
-
-declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #1
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.init(ptr %context) unnamed_addr #2 {
+define hidden void @main.init(ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden %runtime._interface @main.simpleType(ptr %context) unnamed_addr #2 {
+define hidden %runtime._interface @main.simpleType(ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
-  call void @runtime.trackPointer(ptr nonnull @"reflect/types.type:basic:int", ptr nonnull %stackalloc, ptr undef) #7
-  call void @runtime.trackPointer(ptr null, ptr nonnull %stackalloc, ptr undef) #7
+  call void @runtime.trackPointer(ptr nonnull @"reflect/types.type:basic:int", ptr nonnull %stackalloc, ptr undef) #6
+  call void @runtime.trackPointer(ptr null, ptr nonnull %stackalloc, ptr undef) #6
   ret %runtime._interface { ptr @"reflect/types.type:basic:int", ptr null }
 }
 
 ; Function Attrs: nounwind
-define hidden %runtime._interface @main.pointerType(ptr %context) unnamed_addr #2 {
+define hidden %runtime._interface @main.pointerType(ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
-  call void @runtime.trackPointer(ptr nonnull @"reflect/types.type:pointer:basic:int", ptr nonnull %stackalloc, ptr undef) #7
-  call void @runtime.trackPointer(ptr null, ptr nonnull %stackalloc, ptr undef) #7
+  call void @runtime.trackPointer(ptr nonnull @"reflect/types.type:pointer:basic:int", ptr nonnull %stackalloc, ptr undef) #6
+  call void @runtime.trackPointer(ptr null, ptr nonnull %stackalloc, ptr undef) #6
   ret %runtime._interface { ptr @"reflect/types.type:pointer:basic:int", ptr null }
 }
 
 ; Function Attrs: nounwind
-define hidden %runtime._interface @main.interfaceType(ptr %context) unnamed_addr #2 {
+define hidden %runtime._interface @main.interfaceType(ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
-  call void @runtime.trackPointer(ptr nonnull @"reflect/types.type:pointer:named:error", ptr nonnull %stackalloc, ptr undef) #7
-  call void @runtime.trackPointer(ptr null, ptr nonnull %stackalloc, ptr undef) #7
+  call void @runtime.trackPointer(ptr nonnull @"reflect/types.type:pointer:named:error", ptr nonnull %stackalloc, ptr undef) #6
+  call void @runtime.trackPointer(ptr null, ptr nonnull %stackalloc, ptr undef) #6
   ret %runtime._interface { ptr @"reflect/types.type:pointer:named:error", ptr null }
 }
 
 ; Function Attrs: nounwind
-define hidden %runtime._interface @main.anonymousInterfaceType(ptr %context) unnamed_addr #2 {
+define hidden %runtime._interface @main.anonymousInterfaceType(ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
-  call void @runtime.trackPointer(ptr nonnull @"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}", ptr nonnull %stackalloc, ptr undef) #7
-  call void @runtime.trackPointer(ptr null, ptr nonnull %stackalloc, ptr undef) #7
+  call void @runtime.trackPointer(ptr nonnull @"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}", ptr nonnull %stackalloc, ptr undef) #6
+  call void @runtime.trackPointer(ptr null, ptr nonnull %stackalloc, ptr undef) #6
   ret %runtime._interface { ptr @"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}", ptr null }
 }
 
 ; Function Attrs: nounwind
-define hidden i1 @main.isInt(ptr %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #2 {
+define hidden i1 @main.isInt(ptr %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
 entry:
-  %typecode = call i1 @runtime.typeAssert(ptr %itf.typecode, ptr nonnull @"reflect/types.typeid:basic:int", ptr undef) #7
+  %typecode = call i1 @runtime.typeAssert(ptr %itf.typecode, ptr nonnull @"reflect/types.typeid:basic:int", ptr undef) #6
   br i1 %typecode, label %typeassert.ok, label %typeassert.next
 
 typeassert.next:                                  ; preds = %typeassert.ok, %entry
@@ -77,12 +76,12 @@ typeassert.ok:                                    ; preds = %entry
   br label %typeassert.next
 }
 
-declare i1 @runtime.typeAssert(ptr, ptr dereferenceable_or_null(1), ptr) #1
+declare i1 @runtime.typeAssert(ptr, ptr dereferenceable_or_null(1), ptr) #0
 
 ; Function Attrs: nounwind
-define hidden i1 @main.isError(ptr %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #2 {
+define hidden i1 @main.isError(ptr %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
 entry:
-  %0 = call i1 @"interface:{Error:func:{}{basic:string}}.$typeassert"(ptr %itf.typecode) #7
+  %0 = call i1 @"interface:{Error:func:{}{basic:string}}.$typeassert"(ptr %itf.typecode) #6
   br i1 %0, label %typeassert.ok, label %typeassert.next
 
 typeassert.next:                                  ; preds = %typeassert.ok, %entry
@@ -92,12 +91,12 @@ typeassert.ok:                                    ; preds = %entry
   br label %typeassert.next
 }
 
-declare i1 @"interface:{Error:func:{}{basic:string}}.$typeassert"(ptr) #3
+declare i1 @"interface:{Error:func:{}{basic:string}}.$typeassert"(ptr) #2
 
 ; Function Attrs: nounwind
-define hidden i1 @main.isStringer(ptr %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #2 {
+define hidden i1 @main.isStringer(ptr %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
 entry:
-  %0 = call i1 @"interface:{String:func:{}{basic:string}}.$typeassert"(ptr %itf.typecode) #7
+  %0 = call i1 @"interface:{String:func:{}{basic:string}}.$typeassert"(ptr %itf.typecode) #6
   br i1 %0, label %typeassert.ok, label %typeassert.next
 
 typeassert.next:                                  ; preds = %typeassert.ok, %entry
@@ -107,34 +106,33 @@ typeassert.ok:                                    ; preds = %entry
   br label %typeassert.next
 }
 
-declare i1 @"interface:{String:func:{}{basic:string}}.$typeassert"(ptr) #4
+declare i1 @"interface:{String:func:{}{basic:string}}.$typeassert"(ptr) #3
 
 ; Function Attrs: nounwind
-define hidden i8 @main.callFooMethod(ptr %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #2 {
+define hidden i8 @main.callFooMethod(ptr %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
 entry:
-  %0 = call i8 @"interface:{String:func:{}{basic:string},main.foo:func:{basic:int}{basic:uint8}}.foo$invoke"(ptr %itf.value, i32 3, ptr %itf.typecode, ptr undef) #7
+  %0 = call i8 @"interface:{String:func:{}{basic:string},main.foo:func:{basic:int}{basic:uint8}}.foo$invoke"(ptr %itf.value, i32 3, ptr %itf.typecode, ptr undef) #6
   ret i8 %0
 }
 
-declare i8 @"interface:{String:func:{}{basic:string},main.foo:func:{basic:int}{basic:uint8}}.foo$invoke"(ptr, i32, ptr, ptr) #5
+declare i8 @"interface:{String:func:{}{basic:string},main.foo:func:{basic:int}{basic:uint8}}.foo$invoke"(ptr, i32, ptr, ptr) #4
 
 ; Function Attrs: nounwind
-define hidden %runtime._string @main.callErrorMethod(ptr %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #2 {
+define hidden %runtime._string @main.callErrorMethod(ptr %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
-  %0 = call %runtime._string @"interface:{Error:func:{}{basic:string}}.Error$invoke"(ptr %itf.value, ptr %itf.typecode, ptr undef) #7
+  %0 = call %runtime._string @"interface:{Error:func:{}{basic:string}}.Error$invoke"(ptr %itf.value, ptr %itf.typecode, ptr undef) #6
   %1 = extractvalue %runtime._string %0, 0
-  call void @runtime.trackPointer(ptr %1, ptr nonnull %stackalloc, ptr undef) #7
+  call void @runtime.trackPointer(ptr %1, ptr nonnull %stackalloc, ptr undef) #6
   ret %runtime._string %0
 }
 
-declare %runtime._string @"interface:{Error:func:{}{basic:string}}.Error$invoke"(ptr, ptr, ptr) #6
+declare %runtime._string @"interface:{Error:func:{}{basic:string}}.Error$invoke"(ptr, ptr, ptr) #5
 
-attributes #0 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #1 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #2 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #3 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" "tinygo-methods"="reflect/methods.Error() string" }
-attributes #4 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" "tinygo-methods"="reflect/methods.String() string" }
-attributes #5 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" "tinygo-invoke"="main.$methods.foo(int) uint8" "tinygo-methods"="reflect/methods.String() string; main.$methods.foo(int) uint8" }
-attributes #6 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" "tinygo-invoke"="reflect/methods.Error() string" "tinygo-methods"="reflect/methods.Error() string" }
-attributes #7 = { nounwind }
+attributes #0 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #1 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #2 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" "tinygo-methods"="reflect/methods.Error() string" }
+attributes #3 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" "tinygo-methods"="reflect/methods.String() string" }
+attributes #4 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" "tinygo-invoke"="main.$methods.foo(int) uint8" "tinygo-methods"="reflect/methods.String() string; main.$methods.foo(int) uint8" }
+attributes #5 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" "tinygo-invoke"="reflect/methods.Error() string" "tinygo-methods"="reflect/methods.Error() string" }
+attributes #6 = { nounwind }

compiler/testdata/pointer.ll

@@ -3,48 +3,44 @@ source_filename = "pointer.go"
 target datalayout = "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-i128:128-n32:64-S128-ni:1:10:20"
 target triple = "wasm32-unknown-wasi"
 
-; Function Attrs: allockind("alloc,zeroed") allocsize(0)
-declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #0
-
-declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #1
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.init(ptr %context) unnamed_addr #2 {
+define hidden void @main.init(ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden [0 x i32] @main.pointerDerefZero(ptr %x, ptr %context) unnamed_addr #2 {
+define hidden [0 x i32] @main.pointerDerefZero(ptr %x, ptr %context) unnamed_addr #1 {
 entry:
   ret [0 x i32] zeroinitializer
 }
 
 ; Function Attrs: nounwind
-define hidden ptr @main.pointerCastFromUnsafe(ptr %x, ptr %context) unnamed_addr #2 {
+define hidden ptr @main.pointerCastFromUnsafe(ptr %x, ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
-  call void @runtime.trackPointer(ptr %x, ptr nonnull %stackalloc, ptr undef) #3
+  call void @runtime.trackPointer(ptr %x, ptr nonnull %stackalloc, ptr undef) #2
   ret ptr %x
 }
 
 ; Function Attrs: nounwind
-define hidden ptr @main.pointerCastToUnsafe(ptr dereferenceable_or_null(4) %x, ptr %context) unnamed_addr #2 {
+define hidden ptr @main.pointerCastToUnsafe(ptr dereferenceable_or_null(4) %x, ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
-  call void @runtime.trackPointer(ptr %x, ptr nonnull %stackalloc, ptr undef) #3
+  call void @runtime.trackPointer(ptr %x, ptr nonnull %stackalloc, ptr undef) #2
   ret ptr %x
 }
 
 ; Function Attrs: nounwind
-define hidden ptr @main.pointerCastToUnsafeNoop(ptr dereferenceable_or_null(1) %x, ptr %context) unnamed_addr #2 {
+define hidden ptr @main.pointerCastToUnsafeNoop(ptr dereferenceable_or_null(1) %x, ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
-  call void @runtime.trackPointer(ptr %x, ptr nonnull %stackalloc, ptr undef) #3
+  call void @runtime.trackPointer(ptr %x, ptr nonnull %stackalloc, ptr undef) #2
   ret ptr %x
 }
 
-attributes #0 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #1 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #2 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #3 = { nounwind }
+attributes #0 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #1 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #2 = { nounwind }

compiler/testdata/pragma.go

@@ -115,3 +115,8 @@ func doesNotEscapeParam(a *int, b []int, c chan int, d *[0]byte)
 //go:noescape
 func stillEscapes(a *int, b []int, c chan int, d *[0]byte) {
 }
+
+//go:noheap
+func doesHeapAlloc() *int {
+	return new(int)
+}

compiler/testdata/pragma.ll

@@ -11,95 +11,105 @@ target triple = "wasm32-unknown-wasi"
 @undefinedGlobalNotInSection = external global i32, align 4
 @main.multipleGlobalPragmas = hidden global i32 0, section ".global_section", align 1024
 
-; Function Attrs: allockind("alloc,zeroed") allocsize(0)
-declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #0
-
-declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #1
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.init(ptr %context) unnamed_addr #2 {
+define hidden void @main.init(ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define void @extern_func() #3 {
+define void @extern_func() #2 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @somepkg.someFunction1(ptr %context) unnamed_addr #2 {
+define hidden void @somepkg.someFunction1(ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
 
-declare void @somepkg.someFunction2(ptr) #1
+declare void @somepkg.someFunction2(ptr) #0
 
 ; Function Attrs: inlinehint nounwind
-define hidden void @main.inlineFunc(ptr %context) unnamed_addr #4 {
+define hidden void @main.inlineFunc(ptr %context) unnamed_addr #3 {
 entry:
   ret void
 }
 
 ; Function Attrs: noinline nounwind
-define hidden void @main.noinlineFunc(ptr %context) unnamed_addr #5 {
+define hidden void @main.noinlineFunc(ptr %context) unnamed_addr #4 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.useGeneric(ptr %context) unnamed_addr #2 {
+define hidden void @main.useGeneric(ptr %context) unnamed_addr #1 {
 entry:
   call void @"main.noinlineGenericFunc[int8]"(ptr undef)
   ret void
 }
 
 ; Function Attrs: noinline nounwind
-define linkonce_odr hidden void @"main.noinlineGenericFunc[int8]"(ptr %context) unnamed_addr #5 {
+define linkonce_odr hidden void @"main.noinlineGenericFunc[int8]"(ptr %context) unnamed_addr #4 {
 entry:
   ret void
 }
 
 ; Function Attrs: noinline nounwind
-define hidden void @main.functionInSection(ptr %context) unnamed_addr #5 section ".special_function_section" {
+define hidden void @main.functionInSection(ptr %context) unnamed_addr #4 section ".special_function_section" {
 entry:
   ret void
 }
 
 ; Function Attrs: noinline nounwind
-define void @exportedFunctionInSection() #6 section ".special_function_section" {
+define void @exportedFunctionInSection() #5 section ".special_function_section" {
 entry:
   ret void
 }
 
-declare void @main.declaredImport() #7
+declare void @main.declaredImport() #6
 
-declare void @imported() #8
+declare void @imported() #7
 
 ; Function Attrs: nounwind
-define void @exported() #9 {
+define void @exported() #8 {
 entry:
   ret void
 }
 
-declare void @main.undefinedFunctionNotInSection(ptr) #1
+declare void @main.undefinedFunctionNotInSection(ptr) #0
 
-declare void @main.doesNotEscapeParam(ptr nocapture dereferenceable_or_null(4), ptr nocapture, i32, i32, ptr nocapture dereferenceable_or_null(36), ptr nocapture, ptr) #1
+declare void @main.doesNotEscapeParam(ptr nocapture dereferenceable_or_null(4), ptr nocapture, i32, i32, ptr nocapture dereferenceable_or_null(36), ptr nocapture, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.stillEscapes(ptr dereferenceable_or_null(4) %a, ptr %b.data, i32 %b.len, i32 %b.cap, ptr dereferenceable_or_null(36) %c, ptr %d, ptr %context) unnamed_addr #2 {
+define hidden void @main.stillEscapes(ptr dereferenceable_or_null(4) %a, ptr %b.data, i32 %b.len, i32 %b.cap, ptr dereferenceable_or_null(36) %c, ptr %d, ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
 
-attributes #0 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #1 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #2 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #3 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" "wasm-export-name"="extern_func" }
-attributes #4 = { inlinehint nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #5 = { noinline nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #6 = { noinline nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" "wasm-export-name"="exportedFunctionInSection" }
-attributes #7 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" "wasm-import-module"="modulename" "wasm-import-name"="import1" }
-attributes #8 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" "wasm-import-module"="foobar" "wasm-import-name"="imported" }
-attributes #9 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" "wasm-export-name"="exported" }
+; Function Attrs: nounwind
+define hidden ptr @main.doesHeapAlloc(ptr %context) unnamed_addr #1 {
+entry:
+  %stackalloc = alloca i8, align 1
+  %new = call align 4 dereferenceable(4) ptr @runtime.alloc_noheap(i32 4, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #10
+  call void @runtime.trackPointer(ptr nonnull %new, ptr nonnull %stackalloc, ptr undef) #10
+  ret ptr %new
+}
+
+; Function Attrs: allockind("alloc,zeroed") allocsize(0)
+declare noalias nonnull ptr @runtime.alloc_noheap(i32, ptr, ptr) #9
+
+attributes #0 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #1 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #2 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" "wasm-export-name"="extern_func" }
+attributes #3 = { inlinehint nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #4 = { noinline nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #5 = { noinline nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" "wasm-export-name"="exportedFunctionInSection" }
+attributes #6 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" "wasm-import-module"="modulename" "wasm-import-name"="import1" }
+attributes #7 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" "wasm-import-module"="foobar" "wasm-import-name"="imported" }
+attributes #8 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" "wasm-export-name"="exported" }
+attributes #9 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #10 = { nounwind }

compiler/testdata/slice.ll

@@ -3,31 +3,28 @@ source_filename = "slice.go"
 target datalayout = "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-i128:128-n32:64-S128-ni:1:10:20"
 target triple = "wasm32-unknown-wasi"
 
-; Function Attrs: allockind("alloc,zeroed") allocsize(0)
-declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #0
-
-declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #1
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.init(ptr %context) unnamed_addr #2 {
+define hidden void @main.init(ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.sliceLen(ptr %ints.data, i32 %ints.len, i32 %ints.cap, ptr %context) unnamed_addr #2 {
+define hidden i32 @main.sliceLen(ptr %ints.data, i32 %ints.len, i32 %ints.cap, ptr %context) unnamed_addr #1 {
 entry:
   ret i32 %ints.len
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.sliceCap(ptr %ints.data, i32 %ints.len, i32 %ints.cap, ptr %context) unnamed_addr #2 {
+define hidden i32 @main.sliceCap(ptr %ints.data, i32 %ints.len, i32 %ints.cap, ptr %context) unnamed_addr #1 {
 entry:
   ret i32 %ints.cap
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.sliceElement(ptr %ints.data, i32 %ints.len, i32 %ints.cap, i32 %index, ptr %context) unnamed_addr #2 {
+define hidden i32 @main.sliceElement(ptr %ints.data, i32 %ints.len, i32 %ints.cap, i32 %index, ptr %context) unnamed_addr #1 {
 entry:
   %.not = icmp ult i32 %index, %ints.len
   br i1 %.not, label %lookup.next, label %lookup.throw
@@ -42,10 +39,10 @@ lookup.throw:                                     ; preds = %entry
   unreachable
 }
 
-declare void @runtime.lookupPanic(ptr) #1
+declare void @runtime.lookupPanic(ptr) #0
 
 ; Function Attrs: nounwind
-define hidden { ptr, i32, i32 } @main.sliceAppendValues(ptr %ints.data, i32 %ints.len, i32 %ints.cap, ptr %context) unnamed_addr #2 {
+define hidden { ptr, i32, i32 } @main.sliceAppendValues(ptr %ints.data, i32 %ints.len, i32 %ints.cap, ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
   %varargs = call align 4 dereferenceable(12) ptr @runtime.alloc(i32 12, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #5
@@ -66,10 +63,13 @@ entry:
   ret { ptr, i32, i32 } %4
 }
 
-declare { ptr, i32, i32 } @runtime.sliceAppend(ptr, ptr nocapture readonly, i32, i32, i32, i32, ptr, ptr) #1
+; Function Attrs: allockind("alloc,zeroed") allocsize(0)
+declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #2
+
+declare { ptr, i32, i32 } @runtime.sliceAppend(ptr, ptr nocapture readonly, i32, i32, i32, i32, ptr, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden { ptr, i32, i32 } @main.sliceAppendSlice(ptr %ints.data, i32 %ints.len, i32 %ints.cap, ptr %added.data, i32 %added.len, i32 %added.cap, ptr %context) unnamed_addr #2 {
+define hidden { ptr, i32, i32 } @main.sliceAppendSlice(ptr %ints.data, i32 %ints.len, i32 %ints.cap, ptr %added.data, i32 %added.len, i32 %added.cap, ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
   %append.new = call { ptr, i32, i32 } @runtime.sliceAppend(ptr %ints.data, ptr %added.data, i32 %ints.len, i32 %ints.cap, i32 %added.len, i32 4, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #5
@@ -84,7 +84,7 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.sliceCopy(ptr %dst.data, i32 %dst.len, i32 %dst.cap, ptr %src.data, i32 %src.len, i32 %src.cap, ptr %context) unnamed_addr #2 {
+define hidden i32 @main.sliceCopy(ptr %dst.data, i32 %dst.len, i32 %dst.cap, ptr %src.data, i32 %src.len, i32 %src.cap, ptr %context) unnamed_addr #1 {
 entry:
   %copy.n = call i32 @llvm.umin.i32(i32 %dst.len, i32 %src.len)
   %copy.size = shl nuw i32 %copy.n, 2
@@ -99,7 +99,7 @@ declare i32 @llvm.umin.i32(i32, i32) #3
 declare void @llvm.memmove.p0.p0.i32(ptr nocapture writeonly, ptr nocapture readonly, i32, i1 immarg) #4
 
 ; Function Attrs: nounwind
-define hidden { ptr, i32, i32 } @main.makeByteSlice(i32 %len, ptr %context) unnamed_addr #2 {
+define hidden { ptr, i32, i32 } @main.makeByteSlice(i32 %len, ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
   %slice.maxcap = icmp slt i32 %len, 0
@@ -118,10 +118,10 @@ slice.throw:                                      ; preds = %entry
   unreachable
 }
 
-declare void @runtime.slicePanic(ptr) #1
+declare void @runtime.slicePanic(ptr) #0
 
 ; Function Attrs: nounwind
-define hidden { ptr, i32, i32 } @main.makeInt16Slice(i32 %len, ptr %context) unnamed_addr #2 {
+define hidden { ptr, i32, i32 } @main.makeInt16Slice(i32 %len, ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
   %slice.maxcap = icmp slt i32 %len, 0
@@ -142,7 +142,7 @@ slice.throw:                                      ; preds = %entry
 }
 
 ; Function Attrs: nounwind
-define hidden { ptr, i32, i32 } @main.makeArraySlice(i32 %len, ptr %context) unnamed_addr #2 {
+define hidden { ptr, i32, i32 } @main.makeArraySlice(i32 %len, ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
   %slice.maxcap = icmp ugt i32 %len, 1431655765
@@ -163,7 +163,7 @@ slice.throw:                                      ; preds = %entry
 }
 
 ; Function Attrs: nounwind
-define hidden { ptr, i32, i32 } @main.makeInt32Slice(i32 %len, ptr %context) unnamed_addr #2 {
+define hidden { ptr, i32, i32 } @main.makeInt32Slice(i32 %len, ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
   %slice.maxcap = icmp ugt i32 %len, 1073741823
@@ -184,7 +184,7 @@ slice.throw:                                      ; preds = %entry
 }
 
 ; Function Attrs: nounwind
-define hidden ptr @main.Add32(ptr %p, i32 %len, ptr %context) unnamed_addr #2 {
+define hidden ptr @main.Add32(ptr %p, i32 %len, ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
   %0 = getelementptr i8, ptr %p, i32 %len
@@ -193,7 +193,7 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden ptr @main.Add64(ptr %p, i64 %len, ptr %context) unnamed_addr #2 {
+define hidden ptr @main.Add64(ptr %p, i64 %len, ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
   %0 = trunc i64 %len to i32
@@ -203,7 +203,7 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden ptr @main.SliceToArray(ptr %s.data, i32 %s.len, i32 %s.cap, ptr %context) unnamed_addr #2 {
+define hidden ptr @main.SliceToArray(ptr %s.data, i32 %s.len, i32 %s.cap, ptr %context) unnamed_addr #1 {
 entry:
   %0 = icmp ult i32 %s.len, 4
   br i1 %0, label %slicetoarray.throw, label %slicetoarray.next
@@ -216,10 +216,10 @@ slicetoarray.throw:                               ; preds = %entry
   unreachable
 }
 
-declare void @runtime.sliceToArrayPointerPanic(ptr) #1
+declare void @runtime.sliceToArrayPointerPanic(ptr) #0
 
 ; Function Attrs: nounwind
-define hidden ptr @main.SliceToArrayConst(ptr %context) unnamed_addr #2 {
+define hidden ptr @main.SliceToArrayConst(ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
   %makeslice = call align 4 dereferenceable(24) ptr @runtime.alloc(i32 24, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #5
@@ -234,7 +234,7 @@ slicetoarray.throw:                               ; preds = %entry
 }
 
 ; Function Attrs: nounwind
-define hidden { ptr, i32, i32 } @main.SliceInt(ptr dereferenceable_or_null(4) %ptr, i32 %len, ptr %context) unnamed_addr #2 {
+define hidden { ptr, i32, i32 } @main.SliceInt(ptr dereferenceable_or_null(4) %ptr, i32 %len, ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
   %0 = icmp ugt i32 %len, 1073741823
@@ -256,10 +256,10 @@ unsafe.Slice.throw:                               ; preds = %entry
   unreachable
 }
 
-declare void @runtime.unsafeSlicePanic(ptr) #1
+declare void @runtime.unsafeSlicePanic(ptr) #0
 
 ; Function Attrs: nounwind
-define hidden { ptr, i32, i32 } @main.SliceUint16(ptr dereferenceable_or_null(1) %ptr, i16 %len, ptr %context) unnamed_addr #2 {
+define hidden { ptr, i32, i32 } @main.SliceUint16(ptr dereferenceable_or_null(1) %ptr, i16 %len, ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
   %0 = icmp eq ptr %ptr, null
@@ -281,7 +281,7 @@ unsafe.Slice.throw:                               ; preds = %entry
 }
 
 ; Function Attrs: nounwind
-define hidden { ptr, i32, i32 } @main.SliceUint64(ptr dereferenceable_or_null(4) %ptr, i64 %len, ptr %context) unnamed_addr #2 {
+define hidden { ptr, i32, i32 } @main.SliceUint64(ptr dereferenceable_or_null(4) %ptr, i64 %len, ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
   %0 = icmp ugt i64 %len, 1073741823
@@ -305,7 +305,7 @@ unsafe.Slice.throw:                               ; preds = %entry
 }
 
 ; Function Attrs: nounwind
-define hidden { ptr, i32, i32 } @main.SliceInt64(ptr dereferenceable_or_null(4) %ptr, i64 %len, ptr %context) unnamed_addr #2 {
+define hidden { ptr, i32, i32 } @main.SliceInt64(ptr dereferenceable_or_null(4) %ptr, i64 %len, ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
   %0 = icmp ugt i64 %len, 1073741823
@@ -328,9 +328,9 @@ unsafe.Slice.throw:                               ; preds = %entry
   unreachable
 }
 
-attributes #0 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #1 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #2 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #0 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #1 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #2 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
 attributes #3 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
 attributes #4 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
 attributes #5 = { nounwind }

compiler/testdata/string.ll

@@ -7,37 +7,34 @@ target triple = "wasm32-unknown-wasi"
 
 @"main$string" = internal unnamed_addr constant [3 x i8] c"foo", align 1
 
-; Function Attrs: allockind("alloc,zeroed") allocsize(0)
-declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #0
-
-declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #1
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.init(ptr %context) unnamed_addr #2 {
+define hidden void @main.init(ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden %runtime._string @main.someString(ptr %context) unnamed_addr #2 {
+define hidden %runtime._string @main.someString(ptr %context) unnamed_addr #1 {
 entry:
   ret %runtime._string { ptr @"main$string", i32 3 }
 }
 
 ; Function Attrs: nounwind
-define hidden %runtime._string @main.zeroLengthString(ptr %context) unnamed_addr #2 {
+define hidden %runtime._string @main.zeroLengthString(ptr %context) unnamed_addr #1 {
 entry:
   ret %runtime._string zeroinitializer
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.stringLen(ptr readonly %s.data, i32 %s.len, ptr %context) unnamed_addr #2 {
+define hidden i32 @main.stringLen(ptr readonly %s.data, i32 %s.len, ptr %context) unnamed_addr #1 {
 entry:
   ret i32 %s.len
 }
 
 ; Function Attrs: nounwind
-define hidden i8 @main.stringIndex(ptr readonly %s.data, i32 %s.len, i32 %index, ptr %context) unnamed_addr #2 {
+define hidden i8 @main.stringIndex(ptr readonly %s.data, i32 %s.len, i32 %index, ptr %context) unnamed_addr #1 {
 entry:
   %.not = icmp ult i32 %index, %s.len
   br i1 %.not, label %lookup.next, label %lookup.throw
@@ -48,40 +45,40 @@ lookup.next:                                      ; preds = %entry
   ret i8 %1
 
 lookup.throw:                                     ; preds = %entry
-  call void @runtime.lookupPanic(ptr undef) #3
+  call void @runtime.lookupPanic(ptr undef) #2
   unreachable
 }
 
-declare void @runtime.lookupPanic(ptr) #1
+declare void @runtime.lookupPanic(ptr) #0
 
 ; Function Attrs: nounwind
-define hidden i1 @main.stringCompareEqual(ptr readonly %s1.data, i32 %s1.len, ptr readonly %s2.data, i32 %s2.len, ptr %context) unnamed_addr #2 {
+define hidden i1 @main.stringCompareEqual(ptr readonly %s1.data, i32 %s1.len, ptr readonly %s2.data, i32 %s2.len, ptr %context) unnamed_addr #1 {
 entry:
-  %0 = call i1 @runtime.stringEqual(ptr %s1.data, i32 %s1.len, ptr %s2.data, i32 %s2.len, ptr undef) #3
+  %0 = call i1 @runtime.stringEqual(ptr %s1.data, i32 %s1.len, ptr %s2.data, i32 %s2.len, ptr undef) #2
   ret i1 %0
 }
 
-declare i1 @runtime.stringEqual(ptr readonly, i32, ptr readonly, i32, ptr) #1
+declare i1 @runtime.stringEqual(ptr readonly, i32, ptr readonly, i32, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden i1 @main.stringCompareUnequal(ptr readonly %s1.data, i32 %s1.len, ptr readonly %s2.data, i32 %s2.len, ptr %context) unnamed_addr #2 {
+define hidden i1 @main.stringCompareUnequal(ptr readonly %s1.data, i32 %s1.len, ptr readonly %s2.data, i32 %s2.len, ptr %context) unnamed_addr #1 {
 entry:
-  %0 = call i1 @runtime.stringEqual(ptr %s1.data, i32 %s1.len, ptr %s2.data, i32 %s2.len, ptr undef) #3
+  %0 = call i1 @runtime.stringEqual(ptr %s1.data, i32 %s1.len, ptr %s2.data, i32 %s2.len, ptr undef) #2
   %1 = xor i1 %0, true
   ret i1 %1
 }
 
 ; Function Attrs: nounwind
-define hidden i1 @main.stringCompareLarger(ptr readonly %s1.data, i32 %s1.len, ptr readonly %s2.data, i32 %s2.len, ptr %context) unnamed_addr #2 {
+define hidden i1 @main.stringCompareLarger(ptr readonly %s1.data, i32 %s1.len, ptr readonly %s2.data, i32 %s2.len, ptr %context) unnamed_addr #1 {
 entry:
-  %0 = call i1 @runtime.stringLess(ptr %s2.data, i32 %s2.len, ptr %s1.data, i32 %s1.len, ptr undef) #3
+  %0 = call i1 @runtime.stringLess(ptr %s2.data, i32 %s2.len, ptr %s1.data, i32 %s1.len, ptr undef) #2
   ret i1 %0
 }
 
-declare i1 @runtime.stringLess(ptr readonly, i32, ptr readonly, i32, ptr) #1
+declare i1 @runtime.stringLess(ptr readonly, i32, ptr readonly, i32, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden i8 @main.stringLookup(ptr readonly %s.data, i32 %s.len, i8 %x, ptr %context) unnamed_addr #2 {
+define hidden i8 @main.stringLookup(ptr readonly %s.data, i32 %s.len, i8 %x, ptr %context) unnamed_addr #1 {
 entry:
   %0 = zext i8 %x to i32
   %.not = icmp ugt i32 %s.len, %0
@@ -93,11 +90,10 @@ lookup.next:                                      ; preds = %entry
   ret i8 %2
 
 lookup.throw:                                     ; preds = %entry
-  call void @runtime.lookupPanic(ptr undef) #3
+  call void @runtime.lookupPanic(ptr undef) #2
   unreachable
 }
 
-attributes #0 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #1 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #2 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #3 = { nounwind }
+attributes #0 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #1 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #2 = { nounwind }

compiler/testdata/zeromap.ll

@@ -5,19 +5,16 @@ target triple = "wasm32-unknown-wasi"
 
 %main.hasPadding = type { i1, i32, i1 }
 
-; Function Attrs: allockind("alloc,zeroed") allocsize(0)
-declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #0
-
-declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #1
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.init(ptr %context) unnamed_addr #2 {
+define hidden void @main.init(ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
 
 ; Function Attrs: noinline nounwind
-define hidden i32 @main.testZeroGet(ptr dereferenceable_or_null(40) %m, i1 %s.b1, i32 %s.i, i1 %s.b2, ptr %context) unnamed_addr #3 {
+define hidden i32 @main.testZeroGet(ptr dereferenceable_or_null(48) %m, i1 %s.b1, i32 %s.i, i1 %s.b2, ptr %context) unnamed_addr #2 {
 entry:
   %hashmap.key = alloca %main.hasPadding, align 8
   %hashmap.value = alloca i32, align 4
@@ -27,29 +24,23 @@ entry:
   call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %hashmap.value)
   call void @llvm.lifetime.start.p0(i64 12, ptr nonnull %hashmap.key)
   store %main.hasPadding %2, ptr %hashmap.key, align 4
-  %3 = getelementptr inbounds nuw i8, ptr %hashmap.key, i32 1
-  call void @runtime.memzero(ptr nonnull %3, i32 3, ptr undef) #5
-  %4 = getelementptr inbounds nuw i8, ptr %hashmap.key, i32 9
-  call void @runtime.memzero(ptr nonnull %4, i32 3, ptr undef) #5
-  %5 = call i1 @runtime.hashmapBinaryGet(ptr %m, ptr nonnull %hashmap.key, ptr nonnull %hashmap.value, i32 4, ptr undef) #5
+  %3 = call i1 @runtime.hashmapGenericGet(ptr %m, ptr nonnull %hashmap.key, ptr nonnull %hashmap.value, i32 4, ptr undef) #4
   call void @llvm.lifetime.end.p0(i64 12, ptr nonnull %hashmap.key)
-  %6 = load i32, ptr %hashmap.value, align 4
+  %4 = load i32, ptr %hashmap.value, align 4
   call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %hashmap.value)
-  ret i32 %6
+  ret i32 %4
 }
 
 ; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: readwrite)
-declare void @llvm.lifetime.start.p0(i64 immarg, ptr nocapture) #4
+declare void @llvm.lifetime.start.p0(i64 immarg, ptr nocapture) #3
 
-declare void @runtime.memzero(ptr, i32, ptr) #1
-
-declare i1 @runtime.hashmapBinaryGet(ptr dereferenceable_or_null(40), ptr, ptr, i32, ptr) #1
+declare i1 @runtime.hashmapGenericGet(ptr dereferenceable_or_null(48), ptr nocapture, ptr nocapture, i32, ptr) #0
 
 ; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: readwrite)
-declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #4
+declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #3
 
 ; Function Attrs: noinline nounwind
-define hidden void @main.testZeroSet(ptr dereferenceable_or_null(40) %m, i1 %s.b1, i32 %s.i, i1 %s.b2, ptr %context) unnamed_addr #3 {
+define hidden void @main.testZeroSet(ptr dereferenceable_or_null(48) %m, i1 %s.b1, i32 %s.i, i1 %s.b2, ptr %context) unnamed_addr #2 {
 entry:
   %hashmap.key = alloca %main.hasPadding, align 8
   %hashmap.value = alloca i32, align 4
@@ -60,20 +51,16 @@ entry:
   store i32 5, ptr %hashmap.value, align 4
   call void @llvm.lifetime.start.p0(i64 12, ptr nonnull %hashmap.key)
   store %main.hasPadding %2, ptr %hashmap.key, align 4
-  %3 = getelementptr inbounds nuw i8, ptr %hashmap.key, i32 1
-  call void @runtime.memzero(ptr nonnull %3, i32 3, ptr undef) #5
-  %4 = getelementptr inbounds nuw i8, ptr %hashmap.key, i32 9
-  call void @runtime.memzero(ptr nonnull %4, i32 3, ptr undef) #5
-  call void @runtime.hashmapBinarySet(ptr %m, ptr nonnull %hashmap.key, ptr nonnull %hashmap.value, ptr undef) #5
+  call void @runtime.hashmapGenericSet(ptr %m, ptr nonnull %hashmap.key, ptr nonnull %hashmap.value, ptr undef) #4
   call void @llvm.lifetime.end.p0(i64 12, ptr nonnull %hashmap.key)
   call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %hashmap.value)
   ret void
 }
 
-declare void @runtime.hashmapBinarySet(ptr dereferenceable_or_null(40), ptr, ptr, ptr) #1
+declare void @runtime.hashmapGenericSet(ptr dereferenceable_or_null(48), ptr nocapture, ptr nocapture, ptr) #0
 
 ; Function Attrs: noinline nounwind
-define hidden i32 @main.testZeroArrayGet(ptr dereferenceable_or_null(40) %m, [2 x %main.hasPadding] %s, ptr %context) unnamed_addr #3 {
+define hidden i32 @main.testZeroArrayGet(ptr dereferenceable_or_null(48) %m, [2 x %main.hasPadding] %s, ptr %context) unnamed_addr #2 {
 entry:
   %hashmap.key = alloca [2 x %main.hasPadding], align 8
   %hashmap.value = alloca i32, align 4
@@ -84,23 +71,15 @@ entry:
   %hashmap.key.repack1 = getelementptr inbounds nuw i8, ptr %hashmap.key, i32 12
   %s.elt2 = extractvalue [2 x %main.hasPadding] %s, 1
   store %main.hasPadding %s.elt2, ptr %hashmap.key.repack1, align 4
-  %0 = getelementptr inbounds nuw i8, ptr %hashmap.key, i32 1
-  call void @runtime.memzero(ptr nonnull %0, i32 3, ptr undef) #5
-  %1 = getelementptr inbounds nuw i8, ptr %hashmap.key, i32 9
-  call void @runtime.memzero(ptr nonnull %1, i32 3, ptr undef) #5
-  %2 = getelementptr inbounds nuw i8, ptr %hashmap.key, i32 13
-  call void @runtime.memzero(ptr nonnull %2, i32 3, ptr undef) #5
-  %3 = getelementptr inbounds nuw i8, ptr %hashmap.key, i32 21
-  call void @runtime.memzero(ptr nonnull %3, i32 3, ptr undef) #5
-  %4 = call i1 @runtime.hashmapBinaryGet(ptr %m, ptr nonnull %hashmap.key, ptr nonnull %hashmap.value, i32 4, ptr undef) #5
+  %0 = call i1 @runtime.hashmapGenericGet(ptr %m, ptr nonnull %hashmap.key, ptr nonnull %hashmap.value, i32 4, ptr undef) #4
   call void @llvm.lifetime.end.p0(i64 24, ptr nonnull %hashmap.key)
-  %5 = load i32, ptr %hashmap.value, align 4
+  %1 = load i32, ptr %hashmap.value, align 4
   call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %hashmap.value)
-  ret i32 %5
+  ret i32 %1
 }
 
 ; Function Attrs: noinline nounwind
-define hidden void @main.testZeroArraySet(ptr dereferenceable_or_null(40) %m, [2 x %main.hasPadding] %s, ptr %context) unnamed_addr #3 {
+define hidden void @main.testZeroArraySet(ptr dereferenceable_or_null(48) %m, [2 x %main.hasPadding] %s, ptr %context) unnamed_addr #2 {
 entry:
   %hashmap.key = alloca [2 x %main.hasPadding], align 8
   %hashmap.value = alloca i32, align 4
@@ -112,29 +91,20 @@ entry:
   %hashmap.key.repack1 = getelementptr inbounds nuw i8, ptr %hashmap.key, i32 12
   %s.elt2 = extractvalue [2 x %main.hasPadding] %s, 1
   store %main.hasPadding %s.elt2, ptr %hashmap.key.repack1, align 4
-  %0 = getelementptr inbounds nuw i8, ptr %hashmap.key, i32 1
-  call void @runtime.memzero(ptr nonnull %0, i32 3, ptr undef) #5
-  %1 = getelementptr inbounds nuw i8, ptr %hashmap.key, i32 9
-  call void @runtime.memzero(ptr nonnull %1, i32 3, ptr undef) #5
-  %2 = getelementptr inbounds nuw i8, ptr %hashmap.key, i32 13
-  call void @runtime.memzero(ptr nonnull %2, i32 3, ptr undef) #5
-  %3 = getelementptr inbounds nuw i8, ptr %hashmap.key, i32 21
-  call void @runtime.memzero(ptr nonnull %3, i32 3, ptr undef) #5
-  call void @runtime.hashmapBinarySet(ptr %m, ptr nonnull %hashmap.key, ptr nonnull %hashmap.value, ptr undef) #5
+  call void @runtime.hashmapGenericSet(ptr %m, ptr nonnull %hashmap.key, ptr nonnull %hashmap.value, ptr undef) #4
   call void @llvm.lifetime.end.p0(i64 24, ptr nonnull %hashmap.key)
   call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %hashmap.value)
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.main(ptr %context) unnamed_addr #2 {
+define hidden void @main.main(ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
 
-attributes #0 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #1 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #2 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #3 = { noinline nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #4 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
-attributes #5 = { nounwind }
+attributes #0 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #1 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #2 = { noinline nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #3 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
+attributes #4 = { nounwind }

errors_test.go

@@ -38,6 +38,7 @@ func TestErrors(t *testing.T) {
 		{name: "loader-invaliddep"},
 		{name: "loader-invalidpackage"},
 		{name: "loader-nopackage"},
+		{name: "noheap", target: "cortex-m-qemu"},
 		{name: "optimizer"},
 		{name: "syntax"},
 		{name: "types"},

flake.lock

@@ -20,16 +20,16 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1747953325,
-        "narHash": "sha256-y2ZtlIlNTuVJUZCqzZAhIw5rrKP4DOSklev6c8PyCkQ=",
+        "lastModified": 1770136044,
+        "narHash": "sha256-tlFqNG/uzz2++aAmn4v8J0vAkV3z7XngeIIB3rM3650=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "55d1f923c480dadce40f5231feb472e81b0bab48",
+        "rev": "e576e3c9cf9bad747afcddd9e34f51d18c855b4e",
         "type": "github"
       },
       "original": {
         "id": "nixpkgs",
-        "ref": "nixos-25.05",
+        "ref": "nixos-25.11",
         "type": "indirect"
       }
     },

flake.nix

@@ -34,7 +34,7 @@
   inputs = {
     # Use a recent stable release, but fix the version to make it reproducible.
     # This version should be updated from time to time.
-    nixpkgs.url = "nixpkgs/nixos-25.05";
+    nixpkgs.url = "nixpkgs/nixos-25.11";
     flake-utils.url = "github:numtide/flake-utils";
   };
   outputs = { self, nixpkgs, flake-utils }:

go.mod

@@ -1,29 +1,53 @@
 module github.com/tinygo-org/tinygo
 
-go 1.22.0
+go 1.23.0
 
 require (
 	github.com/aykevl/go-wasm v0.0.2-0.20250317121156-42b86c494139
 	github.com/blakesmith/ar v0.0.0-20150311145944-8bd4349a67f2
 	github.com/gofrs/flock v0.8.1
+	github.com/golangci/misspell v0.6.0
 	github.com/google/shlex v0.0.0-20181106134648-c34317bd91bf
 	github.com/inhies/go-bytesize v0.0.0-20220417184213-4913239db9cf
 	github.com/marcinbor85/gohex v0.0.0-20200531091804-343a4b548892
 	github.com/mattn/go-colorable v0.1.13
 	github.com/mattn/go-tty v0.0.4
+	github.com/mgechev/revive v1.3.9
 	github.com/sigurn/crc16 v0.0.0-20211026045750-20ab5afb07e3
-	github.com/tetratelabs/wazero v1.6.0
-	go.bug.st/serial v1.6.0
+	github.com/tetratelabs/wazero v1.9.0
+	go.bug.st/serial v1.6.4
+	go.bytecodealliance.org v0.6.2
+	go.bytecodealliance.org/cm v0.2.2
 	golang.org/x/net v0.35.0
 	golang.org/x/sys v0.30.0
 	golang.org/x/tools v0.30.0
 	gopkg.in/yaml.v2 v2.4.0
-	tinygo.org/x/go-llvm v0.0.0-20250422114502-b8f170971e74
+	tinygo.org/x/espflasher v0.6.0
+	tinygo.org/x/go-llvm v0.0.0-20260422095634-06c6725fe5e6
 )
 
 require (
+	github.com/BurntSushi/toml v1.4.0 // indirect
+	github.com/chavacava/garif v0.1.0 // indirect
+	github.com/coreos/go-semver v0.3.1 // indirect
 	github.com/creack/goselect v0.1.2 // indirect
+	github.com/docker/libtrust v0.0.0-20160708172513-aabc10ec26b7 // indirect
+	github.com/fatih/color v1.17.0 // indirect
+	github.com/fatih/structtag v1.2.0 // indirect
+	github.com/hashicorp/go-version v1.7.0 // indirect
+	github.com/klauspost/compress v1.17.11 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
-	github.com/stretchr/testify v1.8.4 // indirect
+	github.com/mattn/go-runewidth v0.0.9 // indirect
+	github.com/mgechev/dots v0.0.0-20210922191527-e955255bf517 // indirect
+	github.com/mitchellh/go-homedir v1.1.0 // indirect
+	github.com/olekukonko/tablewriter v0.0.5 // indirect
+	github.com/opencontainers/go-digest v1.0.0 // indirect
+	github.com/pkg/errors v0.9.1 // indirect
+	github.com/regclient/regclient v0.8.2 // indirect
+	github.com/sirupsen/logrus v1.9.3 // indirect
+	github.com/spf13/afero v1.11.0 // indirect
+	github.com/ulikunitz/xz v0.5.12 // indirect
+	github.com/urfave/cli/v3 v3.0.0-beta1 // indirect
+	golang.org/x/mod v0.23.0 // indirect
 	golang.org/x/text v0.22.0 // indirect
 )

go.sum

@@ -1,17 +1,36 @@
+github.com/BurntSushi/toml v1.4.0 h1:kuoIxZQy2WRRk1pttg9asf+WVv6tWQuBNVmK8+nqPr0=
+github.com/BurntSushi/toml v1.4.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=
 github.com/aykevl/go-wasm v0.0.2-0.20250317121156-42b86c494139 h1:2O/WuAt8J5id3khcAtVB90czG80m+v0sfkLE07GrCVg=
 github.com/aykevl/go-wasm v0.0.2-0.20250317121156-42b86c494139/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/chavacava/garif v0.1.0 h1:2JHa3hbYf5D9dsgseMKAmc/MZ109otzgNFk5s87H9Pc=
+github.com/chavacava/garif v0.1.0/go.mod h1:XMyYCkEL58DF0oyW4qDjjnPWONs2HBqYKI+UIPD+Gww=
+github.com/coreos/go-semver v0.3.1 h1:yi21YpKnrx1gt5R+la8n5WgS0kCrsPp33dmEyHReZr4=
+github.com/coreos/go-semver v0.3.1/go.mod h1:irMmmIw/7yzSRPWryHsK7EYSg09caPQL03VsM8rvUec=
 github.com/creack/goselect v0.1.2 h1:2DNy14+JPjRBgPzAd1thbQp4BSIihxcBf0IXhQXDRa0=
 github.com/creack/goselect v0.1.2/go.mod h1:a/NhLweNvqIYMuxcMOuWY516Cimucms3DglDzQP3hKY=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/docker/libtrust v0.0.0-20160708172513-aabc10ec26b7 h1:UhxFibDNY/bfvqU5CAUmr9zpesgbU6SWc8/B4mflAE4=
+github.com/docker/libtrust v0.0.0-20160708172513-aabc10ec26b7/go.mod h1:cyGadeNEkKy96OOhEzfZl+yxihPEzKnqJwvfuSUqbZE=
+github.com/fatih/color v1.17.0 h1:GlRw1BRJxkpqUCBKzKOw098ed57fEsKeNjpTe3cSjK4=
+github.com/fatih/color v1.17.0/go.mod h1:YZ7TlrGPkiz6ku9fK3TLD/pl3CpsiFyu8N92HLgmosI=
+github.com/fatih/structtag v1.2.0 h1:/OdNE99OxoI/PqaW/SuSK9uxxT3f/tcSZgon/ssNSx4=
+github.com/fatih/structtag v1.2.0/go.mod h1:mBJUNpUnHmRKrKlQQlmCrh5PuhftFbNv8Ys4/aAZl94=
 github.com/gofrs/flock v0.8.1 h1:+gYjHKf32LDeiEEFhQaotPbLuUXjY5ZqxKgXy7n59aw=
 github.com/gofrs/flock v0.8.1/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU=
+github.com/golangci/misspell v0.6.0 h1:JCle2HUTNWirNlDIAUO44hUsKhOFqGPoC4LZxlaSXDs=
+github.com/golangci/misspell v0.6.0/go.mod h1:keMNyY6R9isGaSAu+4Q8NMBwMPkh15Gtc8UCVoDtAWo=
 github.com/google/shlex v0.0.0-20181106134648-c34317bd91bf h1:7+FW5aGwISbqUtkfmIpZJGRgNFg2ioYPvFaUxdqpDsg=
 github.com/google/shlex v0.0.0-20181106134648-c34317bd91bf/go.mod h1:RpwtwJQFrIEPstU94h88MWPXP2ektJZ8cZ0YntAmXiE=
+github.com/hashicorp/go-version v1.7.0 h1:5tqGy27NaOTB8yJKUZELlFAS/LTKJkrmONwQKeRZfjY=
+github.com/hashicorp/go-version v1.7.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
 github.com/inhies/go-bytesize v0.0.0-20220417184213-4913239db9cf h1:FtEj8sfIcaaBfAKrE1Cwb61YDtYq9JxChK1c7AKce7s=
 github.com/inhies/go-bytesize v0.0.0-20220417184213-4913239db9cf/go.mod h1:yrqSXGoD/4EKfF26AOGzscPOgTTJcyAwM2rpixWT+t4=
+github.com/klauspost/compress v1.17.11 h1:In6xLpyWOi1+C7tXUUWv2ot1QvBjxevKAaI6IXrJmUc=
+github.com/klauspost/compress v1.17.11/go.mod h1:pMDklpSncoRMuLFrf1W9Ss9KT+0rH90U12bZKk7uwG0=
 github.com/marcinbor85/gohex v0.0.0-20200531091804-343a4b548892 h1:6J+qramlHVLmiBOgRiBOnQkno8uprqG6YFFQTt6uYIw=
 github.com/marcinbor85/gohex v0.0.0-20200531091804-343a4b548892/go.mod h1:Pb6XcsXyropB9LNHhnqaknG/vEwYztLkQzVCHv8sQ3M=
 github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
@@ -23,18 +42,57 @@ github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.7/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
+github.com/mattn/go-runewidth v0.0.9 h1:Lm995f3rfxdpd6TSmuVCHVb/QhupuXlYr8sCI/QdE+0=
+github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
 github.com/mattn/go-tty v0.0.4 h1:NVikla9X8MN0SQAqCYzpGyXv0jY7MNl3HOWD2dkle7E=
 github.com/mattn/go-tty v0.0.4/go.mod h1:u5GGXBtZU6RQoKV8gY5W6UhMudbR5vXnUe7j3pxse28=
+github.com/mgechev/dots v0.0.0-20210922191527-e955255bf517 h1:zpIH83+oKzcpryru8ceC6BxnoG8TBrhgAvRg8obzup0=
+github.com/mgechev/dots v0.0.0-20210922191527-e955255bf517/go.mod h1:KQ7+USdGKfpPjXk4Ga+5XxQM4Lm4e3gAogrreFAYpOg=
+github.com/mgechev/revive v1.3.9 h1:18Y3R4a2USSBF+QZKFQwVkBROUda7uoBlkEuBD+YD1A=
+github.com/mgechev/revive v1.3.9/go.mod h1:+uxEIr5UH0TjXWHTno3xh4u7eg6jDpXKzQccA9UGhHU=
+github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
+github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
+github.com/olareg/olareg v0.1.1 h1:Ui7q93zjcoF+U9U71sgqgZWByDoZOpqHitUXEu2xV+g=
+github.com/olareg/olareg v0.1.1/go.mod h1:w8NP4SWrHHtxsFaUiv1lnCnYPm4sN1seCd2h7FK/dc0=
+github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
+github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
+github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U=
+github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/regclient/regclient v0.8.2 h1:23BQ3jWgKYHHIXUhp/S9laVJDHDoOQaQCzXMJ4undVE=
+github.com/regclient/regclient v0.8.2/go.mod h1:uGyetv0o6VLyRDjtfeBqp/QBwRLJ3Hcn07/+8QbhNcM=
+github.com/sergi/go-diff v1.3.1 h1:xkr+Oxo4BOQKmkn/B9eMK0g5Kg/983T9DqqPHwYqD+8=
+github.com/sergi/go-diff v1.3.1/go.mod h1:aMJSSKb2lpPvRNec0+w3fl7LP9IOFzdc9Pa4NFbPK1I=
 github.com/sigurn/crc16 v0.0.0-20211026045750-20ab5afb07e3 h1:aQKxg3+2p+IFXXg97McgDGT5zcMrQoi0EICZs8Pgchs=
 github.com/sigurn/crc16 v0.0.0-20211026045750-20ab5afb07e3/go.mod h1:9/etS5gpQq9BJsJMWg1wpLbfuSnkm8dPF6FdW2JXVhA=
-github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
+github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
+github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
+github.com/spf13/afero v1.11.0 h1:WJQKhtpdm3v2IzqG8VMqrr6Rf3UYpEF239Jy9wNepM8=
+github.com/spf13/afero v1.11.0/go.mod h1:GH9Y3pIexgf1MTIWtNGyogA5MwRIDXGUr+hbWNoBjkY=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
-github.com/tetratelabs/wazero v1.6.0 h1:z0H1iikCdP8t+q341xqepY4EWvHEw8Es7tlqiVzlP3g=
-github.com/tetratelabs/wazero v1.6.0/go.mod h1:0U0G41+ochRKoPKCJlh0jMg1CHkyfK8kDqiirMmKY8A=
-go.bug.st/serial v1.6.0 h1:mAbRGN4cKE2J5gMwsMHC2KQisdLRQssO9WSM+rbZJ8A=
-go.bug.st/serial v1.6.0/go.mod h1:UABfsluHAiaNI+La2iESysd9Vetq7VRdpxvjx7CmmOE=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/tetratelabs/wazero v1.9.0 h1:IcZ56OuxrtaEz8UYNRHBrUa9bYeX9oVY93KspZZBf/I=
+github.com/tetratelabs/wazero v1.9.0/go.mod h1:TSbcXCfFP0L2FGkRPxHphadXPjo1T6W+CseNNY7EkjM=
+github.com/ulikunitz/xz v0.5.12 h1:37Nm15o69RwBkXM0J6A5OlE67RZTfzUxTj8fB3dfcsc=
+github.com/ulikunitz/xz v0.5.12/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
+github.com/urfave/cli/v3 v3.0.0-beta1 h1:6DTaaUarcM0wX7qj5Hcvs+5Dm3dyUTBbEwIWAjcw9Zg=
+github.com/urfave/cli/v3 v3.0.0-beta1/go.mod h1:FnIeEMYu+ko8zP1F9Ypr3xkZMIDqW3DR92yUtY39q1Y=
+go.bug.st/serial v1.6.4 h1:7FmqNPgVp3pu2Jz5PoPtbZ9jJO5gnEnZIvnI1lzve8A=
+go.bug.st/serial v1.6.4/go.mod h1:nofMJxTeNVny/m6+KaafC6vJGj3miwQZ6vW4BZUGJPI=
+go.bytecodealliance.org v0.6.2 h1:Jy4u5DVmSkXgsnwojBhJ+AD/YsJsR3VzVnxF0xRCqTQ=
+go.bytecodealliance.org v0.6.2/go.mod h1:gqjTJm0y9NSksG4py/lSjIQ/SNuIlOQ+hCIEPQwtJgA=
+go.bytecodealliance.org/cm v0.2.2 h1:M9iHS6qs884mbQbIjtLX1OifgyPG9DuMs2iwz8G4WQA=
+go.bytecodealliance.org/cm v0.2.2/go.mod h1:JD5vtVNZv7sBoQQkvBvAAVKJPhR/bqBH7yYXTItMfZI=
 golang.org/x/mod v0.23.0 h1:Zb7khfcRGKk+kqfxFaP5tZqCnDZMjC5VtUBs87Hr6QM=
 golang.org/x/mod v0.23.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY=
 golang.org/x/net v0.35.0 h1:T5GQRQb2y08kTAByq9L4/bz8cipCdA8FbRTXewonqY8=
@@ -44,6 +102,7 @@ golang.org/x/sync v0.11.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20191008105621-543471e840be/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
@@ -56,7 +115,10 @@ gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
 gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-tinygo.org/x/go-llvm v0.0.0-20250422114502-b8f170971e74 h1:ovavgTdIBWCH8YWlcfq9gkpoyT1+IxMKSn+Df27QwE8=
-tinygo.org/x/go-llvm v0.0.0-20250422114502-b8f170971e74/go.mod h1:GFbusT2VTA4I+l4j80b17KFK+6whv69Wtny5U+T8RR0=
+tinygo.org/x/espflasher v0.6.0 h1:CHbGMHAIWq1tB8FKd/QwBpNFw1jvHHxpmvZiF+QOYUo=
+tinygo.org/x/espflasher v0.6.0/go.mod h1:tr5u08HoE67WD5zxJesCiiVF/R1b6Akz3yXwh5zah8U=
+tinygo.org/x/go-llvm v0.0.0-20260422095634-06c6725fe5e6 h1:QSnqFgNV2Ij0T4hM2qKv53fcDAFElxClPjVUZXzYkWU=
+tinygo.org/x/go-llvm v0.0.0-20260422095634-06c6725fe5e6/go.mod h1:GFbusT2VTA4I+l4j80b17KFK+6whv69Wtny5U+T8RR0=

goenv/version.go

@@ -10,7 +10,7 @@ import (
 
 // Version of TinyGo.
 // Update this value before release of new version of software.
-const version = "0.40.1"
+const version = "0.42.0-dev"
 
 // Return TinyGo version, either in the form 0.30.0 or as a development version
 // (like 0.30.0-dev-abcd012).

internal/tools/go.mod

@@ -1,30 +0,0 @@
-// TODO: remove this (by merging it into the top-level go.mod)
-// once the top level go.mod specifies a go new enough to make our version of misspell happy.
-
-module tools
-
-go 1.21
-
-require (
-	github.com/golangci/misspell v0.6.0
-	github.com/mgechev/revive v1.3.9
-)
-
-require (
-	github.com/BurntSushi/toml v1.4.0 // indirect
-	github.com/chavacava/garif v0.1.0 // indirect
-	github.com/fatih/color v1.17.0 // indirect
-	github.com/fatih/structtag v1.2.0 // indirect
-	github.com/hashicorp/go-version v1.7.0 // indirect
-	github.com/mattn/go-colorable v0.1.13 // indirect
-	github.com/mattn/go-isatty v0.0.20 // indirect
-	github.com/mattn/go-runewidth v0.0.9 // indirect
-	github.com/mgechev/dots v0.0.0-20210922191527-e955255bf517 // indirect
-	github.com/mitchellh/go-homedir v1.1.0 // indirect
-	github.com/olekukonko/tablewriter v0.0.5 // indirect
-	github.com/pkg/errors v0.9.1 // indirect
-	github.com/spf13/afero v1.11.0 // indirect
-	golang.org/x/sys v0.22.0 // indirect
-	golang.org/x/text v0.14.0 // indirect
-	golang.org/x/tools v0.23.0 // indirect
-)

internal/tools/go.sum

@@ -1,56 +0,0 @@
-github.com/BurntSushi/toml v1.4.0 h1:kuoIxZQy2WRRk1pttg9asf+WVv6tWQuBNVmK8+nqPr0=
-github.com/BurntSushi/toml v1.4.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=
-github.com/chavacava/garif v0.1.0 h1:2JHa3hbYf5D9dsgseMKAmc/MZ109otzgNFk5s87H9Pc=
-github.com/chavacava/garif v0.1.0/go.mod h1:XMyYCkEL58DF0oyW4qDjjnPWONs2HBqYKI+UIPD+Gww=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/fatih/color v1.17.0 h1:GlRw1BRJxkpqUCBKzKOw098ed57fEsKeNjpTe3cSjK4=
-github.com/fatih/color v1.17.0/go.mod h1:YZ7TlrGPkiz6ku9fK3TLD/pl3CpsiFyu8N92HLgmosI=
-github.com/fatih/structtag v1.2.0 h1:/OdNE99OxoI/PqaW/SuSK9uxxT3f/tcSZgon/ssNSx4=
-github.com/fatih/structtag v1.2.0/go.mod h1:mBJUNpUnHmRKrKlQQlmCrh5PuhftFbNv8Ys4/aAZl94=
-github.com/golangci/misspell v0.6.0 h1:JCle2HUTNWirNlDIAUO44hUsKhOFqGPoC4LZxlaSXDs=
-github.com/golangci/misspell v0.6.0/go.mod h1:keMNyY6R9isGaSAu+4Q8NMBwMPkh15Gtc8UCVoDtAWo=
-github.com/hashicorp/go-version v1.7.0 h1:5tqGy27NaOTB8yJKUZELlFAS/LTKJkrmONwQKeRZfjY=
-github.com/hashicorp/go-version v1.7.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
-github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
-github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
-github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
-github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
-github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-runewidth v0.0.9 h1:Lm995f3rfxdpd6TSmuVCHVb/QhupuXlYr8sCI/QdE+0=
-github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
-github.com/mgechev/dots v0.0.0-20210922191527-e955255bf517 h1:zpIH83+oKzcpryru8ceC6BxnoG8TBrhgAvRg8obzup0=
-github.com/mgechev/dots v0.0.0-20210922191527-e955255bf517/go.mod h1:KQ7+USdGKfpPjXk4Ga+5XxQM4Lm4e3gAogrreFAYpOg=
-github.com/mgechev/revive v1.3.9 h1:18Y3R4a2USSBF+QZKFQwVkBROUda7uoBlkEuBD+YD1A=
-github.com/mgechev/revive v1.3.9/go.mod h1:+uxEIr5UH0TjXWHTno3xh4u7eg6jDpXKzQccA9UGhHU=
-github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
-github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
-github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
-github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
-github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
-github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/spf13/afero v1.11.0 h1:WJQKhtpdm3v2IzqG8VMqrr6Rf3UYpEF239Jy9wNepM8=
-github.com/spf13/afero v1.11.0/go.mod h1:GH9Y3pIexgf1MTIWtNGyogA5MwRIDXGUr+hbWNoBjkY=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
-github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
-github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
-github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
-github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.22.0 h1:RI27ohtqKCnwULzJLqkv897zojh5/DwS/ENaMzUOaWI=
-golang.org/x/sys v0.22.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
-golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
-golang.org/x/tools v0.23.0 h1:SGsXPZ+2l4JsgaCKkx+FQ9YZ5XEtA1GZYuoDjenLjvg=
-golang.org/x/tools v0.23.0/go.mod h1:pnu6ufv6vQkll6szChhK3C3L/ruaIv5eBeztNG8wtsI=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

internal/wasm-tools/README.md

@@ -1,5 +0,0 @@
-# wasm-tools directory
-
-This directory has a separate `go.mod` file because the `wasm-tools-go` module requires Go 1.22, while TinyGo itself supports Go 1.19.
-
-When the minimum Go version for TinyGo is 1.22, this directory can be folded into `internal/tools` and the `go.mod` and `go.sum` files deleted.

internal/wasm-tools/go.mod

@@ -1,22 +0,0 @@
-module github.com/tinygo-org/tinygo/internal/wasm-tools
-
-go 1.23.0
-
-require (
-	go.bytecodealliance.org v0.6.2
-	go.bytecodealliance.org/cm v0.2.2
-)
-
-require (
-	github.com/coreos/go-semver v0.3.1 // indirect
-	github.com/docker/libtrust v0.0.0-20160708172513-aabc10ec26b7 // indirect
-	github.com/klauspost/compress v1.18.0 // indirect
-	github.com/opencontainers/go-digest v1.0.0 // indirect
-	github.com/regclient/regclient v0.8.2 // indirect
-	github.com/sirupsen/logrus v1.9.3 // indirect
-	github.com/tetratelabs/wazero v1.9.0 // indirect
-	github.com/ulikunitz/xz v0.5.12 // indirect
-	github.com/urfave/cli/v3 v3.0.0-beta1 // indirect
-	golang.org/x/mod v0.24.0 // indirect
-	golang.org/x/sys v0.31.0 // indirect
-)

internal/wasm-tools/go.sum

@@ -1,48 +0,0 @@
-github.com/coreos/go-semver v0.3.1 h1:yi21YpKnrx1gt5R+la8n5WgS0kCrsPp33dmEyHReZr4=
-github.com/coreos/go-semver v0.3.1/go.mod h1:irMmmIw/7yzSRPWryHsK7EYSg09caPQL03VsM8rvUec=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/docker/libtrust v0.0.0-20160708172513-aabc10ec26b7 h1:UhxFibDNY/bfvqU5CAUmr9zpesgbU6SWc8/B4mflAE4=
-github.com/docker/libtrust v0.0.0-20160708172513-aabc10ec26b7/go.mod h1:cyGadeNEkKy96OOhEzfZl+yxihPEzKnqJwvfuSUqbZE=
-github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
-github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
-github.com/olareg/olareg v0.1.1 h1:Ui7q93zjcoF+U9U71sgqgZWByDoZOpqHitUXEu2xV+g=
-github.com/olareg/olareg v0.1.1/go.mod h1:w8NP4SWrHHtxsFaUiv1lnCnYPm4sN1seCd2h7FK/dc0=
-github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U=
-github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/regclient/regclient v0.8.2 h1:23BQ3jWgKYHHIXUhp/S9laVJDHDoOQaQCzXMJ4undVE=
-github.com/regclient/regclient v0.8.2/go.mod h1:uGyetv0o6VLyRDjtfeBqp/QBwRLJ3Hcn07/+8QbhNcM=
-github.com/sergi/go-diff v1.3.1 h1:xkr+Oxo4BOQKmkn/B9eMK0g5Kg/983T9DqqPHwYqD+8=
-github.com/sergi/go-diff v1.3.1/go.mod h1:aMJSSKb2lpPvRNec0+w3fl7LP9IOFzdc9Pa4NFbPK1I=
-github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
-github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
-github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-github.com/tetratelabs/wazero v1.9.0 h1:IcZ56OuxrtaEz8UYNRHBrUa9bYeX9oVY93KspZZBf/I=
-github.com/tetratelabs/wazero v1.9.0/go.mod h1:TSbcXCfFP0L2FGkRPxHphadXPjo1T6W+CseNNY7EkjM=
-github.com/ulikunitz/xz v0.5.12 h1:37Nm15o69RwBkXM0J6A5OlE67RZTfzUxTj8fB3dfcsc=
-github.com/ulikunitz/xz v0.5.12/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
-github.com/urfave/cli/v3 v3.0.0-beta1 h1:6DTaaUarcM0wX7qj5Hcvs+5Dm3dyUTBbEwIWAjcw9Zg=
-github.com/urfave/cli/v3 v3.0.0-beta1/go.mod h1:FnIeEMYu+ko8zP1F9Ypr3xkZMIDqW3DR92yUtY39q1Y=
-go.bytecodealliance.org v0.6.2 h1:Jy4u5DVmSkXgsnwojBhJ+AD/YsJsR3VzVnxF0xRCqTQ=
-go.bytecodealliance.org v0.6.2/go.mod h1:gqjTJm0y9NSksG4py/lSjIQ/SNuIlOQ+hCIEPQwtJgA=
-go.bytecodealliance.org/cm v0.2.2 h1:M9iHS6qs884mbQbIjtLX1OifgyPG9DuMs2iwz8G4WQA=
-go.bytecodealliance.org/cm v0.2.2/go.mod h1:JD5vtVNZv7sBoQQkvBvAAVKJPhR/bqBH7yYXTItMfZI=
-golang.org/x/mod v0.24.0 h1:ZfthKaKaT4NrhGVZHO1/WDTwGES4De8KtWO0SIbNJMU=
-golang.org/x/mod v0.24.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww=
-golang.org/x/sync v0.11.0 h1:GGz8+XQP4FvTTrjZPzNKTMFtSXH80RAzG+5ghFPgK9w=
-golang.org/x/sync v0.11.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik=
-golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/tools v0.30.0 h1:BgcpHewrV5AUp2G9MebG4XPFI1E2W41zU1SaqVA9vJY=
-golang.org/x/tools v0.30.0/go.mod h1:c347cR/OJfw5TI+GfX7RUPNMdDRRbjvYTS0jPyvsVtY=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

internal/wasm-tools/tools.go

@@ -1,12 +0,0 @@
-//go:build tools
-
-// Install tools specified in go.mod.
-// See https://marcofranssen.nl/manage-go-tools-via-go-modules for idiom.
-package tools
-
-import (
-	_ "go.bytecodealliance.org/cm"
-	_ "go.bytecodealliance.org/cmd/wit-bindgen-go"
-)
-
-//go:generate go install go.bytecodealliance.org/cmd/wit-bindgen-go

interp/errors.go

@@ -19,6 +19,7 @@ var (
 	errUnsupportedRuntimeInst = errors.New("interp: unsupported instruction (to be emitted at runtime)")
 	errMapAlreadyCreated      = errors.New("interp: map already created")
 	errLoopUnrolled           = errors.New("interp: loop unrolled")
+	errLoopTooLong            = errors.New("interp: loop ran too many iterations")
 )
 
 // This is one of the errors that can be returned from toLLVMValue when the
@@ -29,7 +30,7 @@ var errInvalidPtrToIntSize = errors.New("interp: ptrtoint integer size does not
 func isRecoverableError(err error) bool {
 	return err == errIntegerAsPointer || err == errUnsupportedInst ||
 		err == errUnsupportedRuntimeInst || err == errMapAlreadyCreated ||
-		err == errLoopUnrolled
+		err == errLoopUnrolled || err == errLoopTooLong || err == errInvalidPtrToIntSize
 }
 
 // ErrorLine is one line in a traceback. The position may be missing.

interp/interp.go

@@ -19,35 +19,38 @@ const checks = true
 
 // runner contains all state related to one interp run.
 type runner struct {
-	mod           llvm.Module
-	targetData    llvm.TargetData
-	builder       llvm.Builder
-	pointerSize   uint32                   // cached pointer size from the TargetData
-	dataPtrType   llvm.Type                // often used type so created in advance
-	uintptrType   llvm.Type                // equivalent to uintptr in Go
-	maxAlign      int                      // maximum alignment of an object, alignment of runtime.alloc() result
-	byteOrder     binary.ByteOrder         // big-endian or little-endian
-	debug         bool                     // log debug messages
-	pkgName       string                   // package name of the currently executing package
-	functionCache map[llvm.Value]*function // cache of compiled functions
-	objects       []object                 // slice of objects in memory
-	globals       map[llvm.Value]int       // map from global to index in objects slice
-	start         time.Time
-	timeout       time.Duration
-	callsExecuted uint64
+	mod               llvm.Module
+	targetData        llvm.TargetData
+	builder           llvm.Builder
+	pointerSize       uint32                   // cached pointer size from the TargetData
+	dataPtrType       llvm.Type                // often used type so created in advance
+	uintptrType       llvm.Type                // equivalent to uintptr in Go
+	maxAlign          int                      // maximum alignment of an object, alignment of runtime.alloc() result
+	byteOrder         binary.ByteOrder         // big-endian or little-endian
+	debug             bool                     // log debug messages
+	pkgName           string                   // package name of the currently executing package
+	functionCache     map[llvm.Value]*function // cache of compiled functions
+	objects           []object                 // slice of objects in memory
+	globals           map[llvm.Value]int       // map from global to index in objects slice
+	start             time.Time
+	timeout           time.Duration
+	maxLoopIterations int
+	callsExecuted     uint64
+	interpErr         error // set by Uint/Int when they encounter pointer data
 }
 
-func newRunner(mod llvm.Module, timeout time.Duration, debug bool) *runner {
+func newRunner(mod llvm.Module, timeout time.Duration, maxLoopIterations int, debug bool) *runner {
 	r := runner{
-		mod:           mod,
-		targetData:    llvm.NewTargetData(mod.DataLayout()),
-		byteOrder:     llvmutil.ByteOrder(mod.Target()),
-		debug:         debug,
-		functionCache: make(map[llvm.Value]*function),
-		objects:       []object{{}},
-		globals:       make(map[llvm.Value]int),
-		start:         time.Now(),
-		timeout:       timeout,
+		mod:               mod,
+		targetData:        llvm.NewTargetData(mod.DataLayout()),
+		byteOrder:         llvmutil.ByteOrder(mod.Target()),
+		debug:             debug,
+		functionCache:     make(map[llvm.Value]*function),
+		objects:           []object{{}},
+		globals:           make(map[llvm.Value]int),
+		start:             time.Now(),
+		timeout:           timeout,
+		maxLoopIterations: maxLoopIterations,
 	}
 	r.pointerSize = uint32(r.targetData.PointerSize())
 	r.dataPtrType = llvm.PointerType(mod.Context().Int8Type(), 0)
@@ -64,8 +67,8 @@ func (r *runner) dispose() {
 
 // Run evaluates runtime.initAll function as much as possible at compile time.
 // Set debug to true if it should print output while running.
-func Run(mod llvm.Module, timeout time.Duration, debug bool) error {
-	r := newRunner(mod, timeout, debug)
+func Run(mod llvm.Module, timeout time.Duration, maxLoopIterations int, debug bool) error {
+	r := newRunner(mod, timeout, maxLoopIterations, debug)
 	defer r.dispose()
 
 	initAll := mod.NamedFunction("runtime.initAll")
@@ -204,10 +207,10 @@ func Run(mod llvm.Module, timeout time.Duration, debug bool) error {
 
 // RunFunc evaluates a single package initializer at compile time.
 // Set debug to true if it should print output while running.
-func RunFunc(fn llvm.Value, timeout time.Duration, debug bool) error {
+func RunFunc(fn llvm.Value, timeout time.Duration, maxLoopIterations int, debug bool) error {
 	// Create and initialize *runner object.
 	mod := fn.GlobalParent()
-	r := newRunner(mod, timeout, debug)
+	r := newRunner(mod, timeout, maxLoopIterations, debug)
 	defer r.dispose()
 	initName := fn.Name()
 	if !strings.HasSuffix(initName, ".init") {

interp/interp_test.go

@@ -44,7 +44,7 @@ func runTest(t *testing.T, pathPrefix string) {
 	defer mod.Dispose()
 
 	// Perform the transform.
-	err = Run(mod, 10*time.Minute, false)
+	err = Run(mod, 10*time.Minute, DefaultMaxInterpBlockEntries, false)
 	if err != nil {
 		if err, match := err.(*Error); match {
 			println(err.Error())

interp/interpreter.go

@@ -12,6 +12,12 @@ import (
 	"tinygo.org/x/go-llvm"
 )
 
+// DefaultMaxInterpBlockEntries is the default maximum number of times a single
+// basic block may be entered during interpretation of one function call. This
+// limits how far the interpreter will unroll or evaluate loops before deferring
+// the init function to runtime.
+const DefaultMaxInterpBlockEntries = 1000
+
 func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent string) (value, memoryView, *Error) {
 	mem := memoryView{r: r, parent: parentMem}
 	locals := make([]value, len(fn.locals))
@@ -26,6 +32,10 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 	// This is used to prevent unrolling.
 	var runtimeBlocks map[int]struct{}
 
+	// Track how many times each basic block has been entered, to detect
+	// loops that are too expensive to evaluate at compile time.
+	var blockCounts map[int]int
+
 	// Start with the first basic block and the first instruction.
 	// Branch instructions may modify both bb and instIndex when branching.
 	bb := fn.blocks[0]
@@ -36,6 +46,18 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 	for instIndex := 0; instIndex < len(bb.instructions); instIndex++ {
 		if instIndex == 0 {
 			// This is the start of a new basic block.
+
+			// Check whether this block has been entered too many times,
+			// which indicates an expensive loop that should be deferred
+			// to runtime.
+			if blockCounts == nil {
+				blockCounts = make(map[int]int)
+			}
+			blockCounts[currentBB]++
+			if r.maxLoopIterations > 0 && blockCounts[currentBB] > r.maxLoopIterations {
+				return nil, mem, r.errorAt(bb.instructions[0], errLoopTooLong)
+			}
+
 			if len(mem.instructions) != startRTInsts {
 				if _, ok := runtimeBlocks[lastBB]; ok {
 					// This loop has been unrolled.
@@ -277,7 +299,7 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				// means that monotonic time in the time package is counted from
 				// time.Time{}.Sub(1), which should be fine.
 				locals[inst.localIndex] = literalValue{uint64(0)}
-			case callFn.name == "runtime.alloc":
+			case callFn.name == "runtime.alloc" || callFn.name == "runtime.alloc_noheap":
 				// Allocate heap memory. At compile time, this is instead done
 				// by creating a global variable.
 
@@ -413,64 +435,6 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				// Special function that will trigger an error.
 				// This is used to test error reporting.
 				return nil, mem, r.errorAt(inst, errors.New("test error"))
-			case strings.HasSuffix(callFn.name, ".$typeassert"):
-				if r.debug {
-					fmt.Fprintln(os.Stderr, indent+"interface assert:", operands[1:])
-				}
-
-				// Load various values for the interface implements check below.
-				typecodePtr, err := operands[1].asPointer(r)
-				if err != nil {
-					return nil, mem, r.errorAt(inst, err)
-				}
-				// typecodePtr always point to the numMethod field in the type
-				// description struct. The methodSet, when present, comes right
-				// before the numMethod field (the compiler doesn't generate
-				// method sets for concrete types without methods).
-				// Considering that the compiler doesn't emit interface type
-				// asserts for interfaces with no methods (as the always succeed)
-				// then if the offset is zero, this assert must always fail.
-				if typecodePtr.offset() == 0 {
-					locals[inst.localIndex] = literalValue{uint8(0)}
-					break
-				}
-				typecodePtrOffset, err := typecodePtr.addOffset(-int64(r.pointerSize))
-				if err != nil {
-					return nil, mem, r.errorAt(inst, err)
-				}
-				methodSetPtr, err := mem.load(typecodePtrOffset, r.pointerSize).asPointer(r)
-				if err != nil {
-					return nil, mem, r.errorAt(inst, err)
-				}
-				methodSet := mem.get(methodSetPtr.index()).llvmGlobal.Initializer()
-				numMethods := int(r.builder.CreateExtractValue(methodSet, 0, "").ZExtValue())
-				llvmFn := inst.llvmInst.CalledValue()
-				methodSetAttr := llvmFn.GetStringAttributeAtIndex(-1, "tinygo-methods")
-				methodSetString := methodSetAttr.GetStringValue()
-
-				// Make a set of all the methods on the concrete type, for
-				// easier checking in the next step.
-				concreteTypeMethods := map[string]struct{}{}
-				for i := 0; i < numMethods; i++ {
-					methodInfo := r.builder.CreateExtractValue(methodSet, 1, "")
-					name := r.builder.CreateExtractValue(methodInfo, i, "").Name()
-					concreteTypeMethods[name] = struct{}{}
-				}
-
-				// Check whether all interface methods are also in the list
-				// of defined methods calculated above. This is the interface
-				// assert itself.
-				assertOk := uint8(1) // i1 true
-				for _, name := range strings.Split(methodSetString, "; ") {
-					if _, ok := concreteTypeMethods[name]; !ok {
-						// There is a method on the interface that is not
-						// implemented by the type. The assertion will fail.
-						assertOk = 0 // i1 false
-						break
-					}
-				}
-				// If assertOk is still 1, the assertion succeeded.
-				locals[inst.localIndex] = literalValue{assertOk}
 			case strings.HasSuffix(callFn.name, "$invoke"):
 				// This thunk is the interface method dispatcher: it is called
 				// with all regular parameters and a type code. It will then
@@ -883,6 +847,14 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 			}
 			return nil, mem, r.errorAt(inst, errUnsupportedInst)
 		}
+
+		// Check if an instruction triggered a recoverable error (e.g.,
+		// trying to interpret pointer data as integer bytes).
+		if r.interpErr != nil {
+			err := r.interpErr
+			r.interpErr = nil
+			return nil, mem, r.errorAt(inst, err)
+		}
 	}
 	return nil, mem, r.errorAt(bb.instructions[len(bb.instructions)-1], errors.New("interp: reached end of basic block without terminator"))
 }

interp/memory.go

@@ -556,11 +556,13 @@ func (v pointerValue) asRawValue(r *runner) rawValue {
 }
 
 func (v pointerValue) Uint(r *runner) uint64 {
-	panic("cannot convert pointer to integer")
+	r.interpErr = errUnsupportedInst
+	return 0
 }
 
 func (v pointerValue) Int(r *runner) int64 {
-	panic("cannot convert pointer to integer")
+	r.interpErr = errUnsupportedInst
+	return 0
 }
 
 func (v pointerValue) equal(rhs pointerValue) bool {
@@ -736,11 +738,12 @@ func (v rawValue) asRawValue(r *runner) rawValue {
 	return v
 }
 
-func (v rawValue) bytes() []byte {
+func (v rawValue) bytes(r *runner) []byte {
 	buf := make([]byte, len(v.buf))
 	for i, p := range v.buf {
 		if p > 255 {
-			panic("cannot convert pointer value to byte")
+			r.interpErr = errUnsupportedInst
+			return buf
 		}
 		buf[i] = byte(p)
 	}
@@ -748,7 +751,10 @@ func (v rawValue) bytes() []byte {
 }
 
 func (v rawValue) Uint(r *runner) uint64 {
-	buf := v.bytes()
+	buf := v.bytes(r)
+	if r.interpErr != nil {
+		return 0
+	}
 
 	switch len(v.buf) {
 	case 1:

loader/goroot.go

@@ -245,6 +245,7 @@ func pathsToOverride(goMinor int, needsSyscallPackage bool) map[string]bool {
 		"internal/cm/":                false,
 		"internal/futex/":             false,
 		"internal/fuzz/":              false,
+		"internal/itoa/":              false,
 		"internal/reflectlite/":       false,
 		"internal/gclayout":           false,
 		"internal/task/":              false,
@@ -267,11 +268,31 @@ func pathsToOverride(goMinor int, needsSyscallPackage bool) map[string]bool {
 		paths["crypto/internal/boring/sig/"] = false
 	}
 
+	if goMinor >= 26 {
+		// Go 1.26 added a CPU jitter entropy source for FIPS 140-3 that
+		// allocates a 32 MiB global buffer (ScratchBuffer [1<<25]byte).
+		// This is fine on systems with virtual memory, but causes RAM
+		// overflow on microcontrollers. Replace with a zero-size stub
+		// since TinyGo targets never use FIPS jitter entropy.
+		paths["crypto/internal/entropy/"] = true
+		paths["crypto/internal/entropy/v1.0.0/"] = false
+	}
+
 	if needsSyscallPackage {
 		paths["syscall/"] = true // include syscall/js
 		paths["internal/syscall/"] = true
 		paths["internal/syscall/unix/"] = false
 	}
+
+	if goMinor >= 26 {
+		// Go 1.26 added SWAR optimizations to unicode/utf8 that use
+		// constants assuming at least 32-bit uintptr. TinyGo supports
+		// 16-bit targets (AVR) where these constants overflow, so we
+		// provide a patched version.
+		paths["unicode/"] = true
+		paths["unicode/utf8/"] = false
+	}
+
 	return paths
 }
 

loader/loader.go

@@ -304,6 +304,29 @@ func (p *Program) Sorted() []*Package {
 	return p.sorted
 }
 
+// StripVarInitializer removes the package-level initializer for the named
+// variable from the type info. This prevents go/ssa from emitting an init
+// store for it, leaving the global zero-initialized in the IR. An external
+// value (e.g. from -ldflags -X via makeGlobalsModule) can then be linked in
+// at final link time without any runtime init overwriting it.
+//
+// Must be called after Parse() (typechecking populates InitOrder) and before
+// LoadSSA() (which consumes InitOrder to build the package init function).
+//
+// Only 1:1 var initializers (var x = expr) are matched. Multi-variable
+// initializers (var x, y = f()) are left untouched.
+func (p *Package) StripVarInitializer(name string) {
+	n := 0
+	for _, init := range p.info.InitOrder {
+		if len(init.Lhs) == 1 && init.Lhs[0].Name() == name {
+			continue // drop this initializer
+		}
+		p.info.InitOrder[n] = init
+		n++
+	}
+	p.info.InitOrder = p.info.InitOrder[:n]
+}
+
 // MainPkg returns the last package in the Sorted() slice. This is the main
 // package of the program.
 func (p *Program) MainPkg() *Package {
@@ -549,7 +572,7 @@ func (p *Package) extractEmbedLines(addError func(error)) {
 					}
 
 					// Look for //go:embed comments.
-					var allPatterns []string
+					var allPatterns []embedPattern
 					for _, comment := range doc.List {
 						if comment.Text != "//go:embed" && !strings.HasPrefix(comment.Text, "//go:embed ") {
 							continue
@@ -577,21 +600,7 @@ func (p *Package) extractEmbedLines(addError func(error)) {
 							})
 							continue
 						}
-						for _, pattern := range patterns {
-							// Check that the pattern is well-formed.
-							// It must be valid: the Go toolchain has already
-							// checked for invalid patterns. But let's check
-							// anyway to be sure.
-							if _, err := path.Match(pattern, ""); err != nil {
-								addError(types.Error{
-									Fset: p.program.fset,
-									Pos:  comment.Pos(),
-									Msg:  "invalid pattern syntax",
-								})
-								continue
-							}
-							allPatterns = append(allPatterns, pattern)
-						}
+						allPatterns = append(allPatterns, patterns...)
 					}
 
 					if len(allPatterns) != 0 {
@@ -624,8 +633,8 @@ func (p *Package) extractEmbedLines(addError func(error)) {
 						// Match all //go:embed patterns against the embed files
 						// provided by `go list`.
 						for _, name := range p.EmbedFiles {
-							for _, pattern := range allPatterns {
-								if matchPattern(pattern, name) {
+							for _, ep := range allPatterns {
+								if ep.Match(name) {
 									p.EmbedGlobals[globalName] = append(p.EmbedGlobals[globalName], &EmbedFile{
 										Name:      name,
 										NeedsData: byteSlice,
@@ -641,13 +650,37 @@ func (p *Package) extractEmbedLines(addError func(error)) {
 	}
 }
 
-// matchPattern returns true if (and only if) the given pattern would match the
-// filename. The pattern could also match a parent directory of name, in which
-// case hidden files do not match.
-func matchPattern(pattern, name string) bool {
+// embedPattern represents a valid //go:embed pattern.
+// See: https://pkg.go.dev/embed#hdr-Directives
+type embedPattern struct {
+	pattern       string // glob pattern without "all:" prefix
+	includeHidden bool   // true if "all:" prefix was present
+}
+
+// newEmbedPattern parses and validates a //go:embed pattern.
+// The "all:" prefix (if present) is stripped and reflected in includeHidden.
+// Returns an error if the pattern syntax is invalid.
+func newEmbedPattern(s string) (embedPattern, error) {
+	ep := embedPattern{pattern: s}
+	if strings.HasPrefix(s, "all:") {
+		ep.pattern = s[4:]
+		ep.includeHidden = true
+	}
+	if _, err := path.Match(ep.pattern, ""); err != nil {
+		return embedPattern{}, err
+	}
+	return ep, nil
+}
+
+// Match returns true if (and only if) the pattern matches the given filename.
+// The pattern could also match a parent directory of name, in which case hidden
+// files do not match (unless includeHidden is true).
+func (ep embedPattern) Match(name string) bool {
+	pattern := ep.pattern
+	includeHidden := ep.includeHidden
+
 	// Match this file.
-	matched, _ := path.Match(pattern, name)
-	if matched {
+	if matched, _ := path.Match(pattern, name); matched {
 		return true
 	}
 
@@ -661,17 +694,20 @@ func matchPattern(pattern, name string) bool {
 		dir = path.Clean(dir)
 		if matched, _ := path.Match(pattern, dir); matched {
 			// Pattern matches the directory.
-			suffix := name[len(dir):]
-			if strings.Contains(suffix, "/_") || strings.Contains(suffix, "/.") {
-				// Pattern matches a hidden file.
-				// Hidden files are included when listed directly as a
-				// pattern, but not when they are part of a directory tree.
-				// Source:
-				// > If a pattern names a directory, all files in the
-				// > subtree rooted at that directory are embedded
-				// > (recursively), except that files with names beginning
-				// > with ‘.’ or ‘_’ are excluded.
-				return false
+			if !includeHidden {
+				suffix := name[len(dir):]
+				if strings.Contains(suffix, "/_") || strings.Contains(suffix, "/.") {
+					// Pattern matches a hidden file.
+					// Hidden files are included when listed directly as a
+					// pattern, or when the "all:" prefix is used, but not
+					// when they are part of a directory tree without "all:".
+					// Source:
+					// > If a pattern names a directory, all files in the
+					// > subtree rooted at that directory are embedded
+					// > (recursively), except that files with names beginning
+					// > with ‘.’ or ‘_’ are excluded.
+					return false
+				}
 			}
 			return true
 		}
@@ -680,11 +716,12 @@ func matchPattern(pattern, name string) bool {
 
 // parseGoEmbed is like strings.Fields but for a //go:embed line. It parses
 // regular fields and quoted fields (that may contain spaces).
-func (p *Package) parseGoEmbed(args string, pos token.Pos) (patterns []string, err error) {
+func (p *Package) parseGoEmbed(args string, pos token.Pos) (patterns []embedPattern, err error) {
 	args = strings.TrimSpace(args)
 	initialLen := len(args)
 	for args != "" {
 		patternPos := pos + token.Pos(initialLen-len(args))
+		var pattern string
 		switch args[0] {
 		case '`', '"', '\\':
 			// Parse the next pattern using the Go scanner.
@@ -703,8 +740,7 @@ func (p *Package) parseGoEmbed(args string, pos token.Pos) (patterns []string, e
 					Msg:  "invalid quoted string in //go:embed",
 				}
 			}
-			pattern := constant.StringVal(constant.MakeFromLiteral(lit, tok, 0))
-			patterns = append(patterns, pattern)
+			pattern = constant.StringVal(constant.MakeFromLiteral(lit, tok, 0))
 			args = strings.TrimLeftFunc(args[len(lit):], unicode.IsSpace)
 		default:
 			// The value is just a regular value.
@@ -713,17 +749,18 @@ func (p *Package) parseGoEmbed(args string, pos token.Pos) (patterns []string, e
 			if index < 0 {
 				index = len(args)
 			}
-			pattern := args[:index]
-			patterns = append(patterns, pattern)
+			pattern = args[:index]
 			args = strings.TrimLeftFunc(args[len(pattern):], unicode.IsSpace)
 		}
-		if _, err := path.Match(patterns[len(patterns)-1], ""); err != nil {
+		ep, err := newEmbedPattern(pattern)
+		if err != nil {
 			return nil, types.Error{
 				Fset: p.program.fset,
 				Pos:  patternPos,
 				Msg:  "invalid pattern syntax",
 			}
 		}
+		patterns = append(patterns, ep)
 	}
 	return patterns, nil
 }

main.go

@@ -30,14 +30,18 @@ import (
 	"github.com/tinygo-org/tinygo/compileopts"
 	"github.com/tinygo-org/tinygo/diagnostics"
 	"github.com/tinygo-org/tinygo/goenv"
+	"github.com/tinygo-org/tinygo/interp"
 	"github.com/tinygo-org/tinygo/loader"
 	"golang.org/x/tools/go/buildutil"
+	"tinygo.org/x/espflasher/pkg/espflasher"
 	"tinygo.org/x/go-llvm"
 
 	"go.bug.st/serial"
 	"go.bug.st/serial/enumerator"
 )
 
+var errInheritableOnly = errors.New("target is inheritable-only, which means it cannot be used directly for building or flashing")
+
 // commandError is an error type to wrap os/exec.Command errors. This provides
 // some more information regarding what went wrong while running a command.
 type commandError struct {
@@ -139,6 +143,10 @@ func printCommand(cmd string, args ...string) {
 
 // Build compiles and links the given package and writes it to outpath.
 func Build(pkgName, outpath string, config *compileopts.Config) error {
+	if config.Target != nil && config.Target.InheritableOnly {
+		return errInheritableOnly
+	}
+
 	// Create a temporary directory for intermediary files.
 	tmpdir, err := os.MkdirTemp("", "tinygo")
 	if err != nil {
@@ -356,6 +364,10 @@ func Flash(pkgName, port, outpath string, options *compileopts.Options) error {
 		return err
 	}
 
+	if config.Target != nil && config.Target.InheritableOnly {
+		return errInheritableOnly
+	}
+
 	// determine the type of file to compile
 	var fileExt string
 
@@ -385,6 +397,10 @@ func Flash(pkgName, port, outpath string, options *compileopts.Options) error {
 		fileExt = ".hex"
 	case "bmp":
 		fileExt = ".elf"
+	case "adb":
+		fileExt = ".hex"
+	case "esp32flash", "esp32jtag":
+		fileExt = ".bin"
 	case "native":
 		return errors.New("unknown flash method \"native\" - did you miss a -target flag?")
 	default:
@@ -519,11 +535,61 @@ func Flash(pkgName, port, outpath string, options *compileopts.Options) error {
 		if err != nil {
 			return &commandError{"failed to flash", result.Binary, err}
 		}
+	case "adb":
+		// Run pre-flash adb shell commands.
+		for _, preCmd := range config.Target.ADBPreCommands {
+			cmd := executeCommand(config.Options, "adb", "shell", preCmd)
+			cmd.Stdout = os.Stdout
+			cmd.Stderr = os.Stderr
+			if err := cmd.Run(); err != nil {
+				return &commandError{"failed to run adb pre-command", preCmd, err}
+			}
+		}
+
+		// Push the binary to the device.
+		if config.Target.ADBPushRemote == "" {
+			return errors.New("invalid target file: flash-method was set to \"adb\" but no adb-push-remote was set")
+		}
+		cmd := executeCommand(config.Options, "adb", "push", result.Binary, config.Target.ADBPushRemote)
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		if err := cmd.Run(); err != nil {
+			return &commandError{"adb push failed to " + config.Target.ADBPushRemote, result.Binary, err}
+		}
+
+		// Run post-flash adb shell commands.
+		for _, postCmd := range config.Target.ADBPostCommands {
+			postCmd = strings.ReplaceAll(postCmd, "{remote}", config.Target.ADBPushRemote)
+			cmd := executeCommand(config.Options, "adb", "shell", postCmd)
+			cmd.Stdout = os.Stdout
+			cmd.Stderr = os.Stderr
+			if err := cmd.Run(); err != nil {
+				return &commandError{"failed to run adb post-command", postCmd, err}
+			}
+		}
+	case "esp32flash":
+		port, err := getDefaultPort(port, config.Target.SerialPort)
+		if err != nil {
+			return &commandError{"failed to find port", port, err}
+		}
+
+		if err := flashBinUsingEsp32(port, classicReset, result.Binary, config.Options); err != nil {
+			return &commandError{"failed to flash", result.Binary, err}
+		}
+	case "esp32jtag":
+		port, err := getDefaultPort(port, config.Target.SerialPort)
+		if err != nil {
+			return &commandError{"failed to find port", port, err}
+		}
+
+		if err := flashBinUsingEsp32(port, jtagReset, result.Binary, config.Options); err != nil {
+			return &commandError{"failed to flash", result.Binary, err}
+		}
 	default:
 		return fmt.Errorf("unknown flash method: %s", flashMethod)
 	}
 	if options.Monitor {
-		return Monitor(result.Executable, "", config)
+		return Monitor(result.Executable, port, config)
 	}
 	return nil
 }
@@ -765,6 +831,10 @@ func Run(pkgName string, options *compileopts.Options, cmdArgs []string) error {
 		return err
 	}
 
+	if config.Target != nil && config.Target.InheritableOnly {
+		return errInheritableOnly
+	}
+
 	_, err = buildAndRun(pkgName, config, os.Stdout, cmdArgs, nil, 0, func(cmd *exec.Cmd, result builder.BuildResult) error {
 		return cmd.Run()
 	})
@@ -1019,6 +1089,68 @@ func flashHexUsingMSD(volumes []string, tmppath string, options *compileopts.Opt
 	return errors.New("unable to locate any volume: [" + strings.Join(volumes, ",") + "]")
 }
 
+const (
+	defaultReset = "default"
+	classicReset = "classic"
+	jtagReset    = "jtag"
+)
+
+func flashBinUsingEsp32(port, resetMode, tmppath string, options *compileopts.Options) error {
+	opts := espflasher.DefaultOptions()
+	opts.Compress = true
+	opts.Logger = &espflasher.StdoutLogger{W: os.Stdout}
+	if options.BaudRate != 0 {
+		opts.FlashBaudRate = options.BaudRate
+	}
+
+	if resetMode == jtagReset {
+		opts.ResetMode = espflasher.ResetUSBJTAG
+	}
+
+	flasher, err := espflasher.New(port, opts)
+	if err != nil {
+		return err
+	}
+	defer flasher.Close()
+
+	chipName := flasher.ChipName()
+	offset := uint32(0x0)
+	if chipName == "ESP32" {
+		offset = 0x1000
+	}
+
+	// Read the firmware binary
+	data, err := os.ReadFile(tmppath)
+	if err != nil {
+		return err
+	}
+
+	if err := flasher.EraseFlash(); err != nil {
+		return fmt.Errorf("erase failed: %v", err)
+	}
+
+	progress := func(current, total int) {
+		pct := float64(current) / float64(total) * 100
+		bar := int(pct / 2)
+		fmt.Printf("\r[%-50s] %6.1f%%", strings.Repeat("#", bar)+strings.Repeat(".", 50-bar), pct)
+		if current >= total {
+			fmt.Println()
+		}
+	}
+
+	// Flash with progress reporting
+	err = flasher.FlashImage(data, offset, progress)
+	if err != nil {
+		return err
+	}
+	fmt.Println()
+
+	// Reset the device to run the new firmware
+	flasher.Reset()
+
+	return nil
+}
+
 type mountPoint struct {
 	name string
 	path string
@@ -1607,6 +1739,7 @@ func main() {
 	serial := flag.String("serial", "", "which serial output to use (none, uart, usb, rtt)")
 	work := flag.Bool("work", false, "print the name of the temporary build directory and do not delete this directory on exit")
 	interpTimeout := flag.Duration("interp-timeout", 180*time.Second, "interp optimization pass timeout")
+	interpLoopLimit := flag.Int("interp-loop-limit", interp.DefaultMaxInterpBlockEntries, "maximum loop iterations during interp (0 to disable)")
 	var tags buildutil.TagsFlag
 	flag.Var(&tags, "tags", "a space-separated list of extra build tags")
 	target := flag.String("target", "", "chip/board name or JSON target specification file")
@@ -1724,42 +1857,43 @@ func main() {
 	}
 
 	options := &compileopts.Options{
-		GOOS:            goenv.Get("GOOS"),
-		GOARCH:          goenv.Get("GOARCH"),
-		GOARM:           goenv.Get("GOARM"),
-		GOMIPS:          goenv.Get("GOMIPS"),
-		Target:          *target,
-		BuildMode:       *buildMode,
-		StackSize:       stackSize,
-		Opt:             *opt,
-		GC:              *gc,
-		PanicStrategy:   *panicStrategy,
-		Scheduler:       *scheduler,
-		Serial:          *serial,
-		Work:            *work,
-		InterpTimeout:   *interpTimeout,
-		PrintIR:         *printIR,
-		DumpSSA:         *dumpSSA,
-		VerifyIR:        *verifyIR,
-		SkipDWARF:       *skipDwarf,
-		Semaphore:       make(chan struct{}, *parallelism),
-		Debug:           !*nodebug,
-		Nobounds:        *nobounds,
-		PrintSizes:      *printSize,
-		PrintStacks:     *printStacks,
-		PrintAllocs:     printAllocs,
-		Tags:            []string(tags),
-		TestConfig:      testConfig,
-		GlobalValues:    globalVarValues,
-		Programmer:      *programmer,
-		OpenOCDCommands: ocdCommands,
-		LLVMFeatures:    *llvmFeatures,
-		Monitor:         *monitor,
-		BaudRate:        *baudrate,
-		Timeout:         *timeout,
-		WITPackage:      witPackage,
-		WITWorld:        witWorld,
-		GoCompatibility: *gocompatibility,
+		GOOS:                    goenv.Get("GOOS"),
+		GOARCH:                  goenv.Get("GOARCH"),
+		GOARM:                   goenv.Get("GOARM"),
+		GOMIPS:                  goenv.Get("GOMIPS"),
+		Target:                  *target,
+		BuildMode:               *buildMode,
+		StackSize:               stackSize,
+		Opt:                     *opt,
+		GC:                      *gc,
+		PanicStrategy:           *panicStrategy,
+		Scheduler:               *scheduler,
+		Serial:                  *serial,
+		Work:                    *work,
+		InterpTimeout:           *interpTimeout,
+		InterpMaxLoopIterations: *interpLoopLimit,
+		PrintIR:                 *printIR,
+		DumpSSA:                 *dumpSSA,
+		VerifyIR:                *verifyIR,
+		SkipDWARF:               *skipDwarf,
+		Semaphore:               make(chan struct{}, *parallelism),
+		Debug:                   !*nodebug,
+		Nobounds:                *nobounds,
+		PrintSizes:              *printSize,
+		PrintStacks:             *printStacks,
+		PrintAllocs:             printAllocs,
+		Tags:                    []string(tags),
+		TestConfig:              testConfig,
+		GlobalValues:            globalVarValues,
+		Programmer:              *programmer,
+		OpenOCDCommands:         ocdCommands,
+		LLVMFeatures:            *llvmFeatures,
+		Monitor:                 *monitor,
+		BaudRate:                *baudrate,
+		Timeout:                 *timeout,
+		WITPackage:              witPackage,
+		WITWorld:                witWorld,
+		GoCompatibility:         *gocompatibility,
 	}
 	if *printCommands {
 		options.PrintCommands = printCommand

main_test.go

@@ -77,6 +77,7 @@ func TestBuild(t *testing.T) {
 		"interface.go",
 		"json.go",
 		"map.go",
+		"map_bigkey.go",
 		"math.go",
 		"oldgo/",
 		"print.go",
@@ -107,6 +108,9 @@ func TestBuild(t *testing.T) {
 	if minor >= 23 {
 		tests = append(tests, "go1.23/")
 	}
+	if minor >= 24 {
+		tests = append(tests, "typealias.go")
+	}
 
 	if *testTarget != "" {
 		// This makes it possible to run one specific test (instead of all),
@@ -152,6 +156,19 @@ func TestBuild(t *testing.T) {
 			}
 			runTestWithConfig("ldflags.go", t, opts, nil, nil)
 		})
+
+		// Same as ldflags, but the global has a default value in source.
+		// -ldflags -X must override it, matching standard Go behaviour.
+		t.Run("ldflags-initialized", func(t *testing.T) {
+			t.Parallel()
+			opts := optionsFromTarget("", sema)
+			opts.GlobalValues = map[string]map[string]string{
+				"main": {
+					"someGlobal": "foobar",
+				},
+			}
+			runTestWithConfig("ldflags-initialized.go", t, opts, nil, nil)
+		})
 	})
 
 	if testing.Short() {
@@ -280,6 +297,11 @@ func runPlatTests(options compileopts.Options, tests []string, t *testing.T) {
 				// limited amount of memory.
 				continue
 
+			case "map_bigkey.go":
+				// Compiler generates many large stack temporaries for [256]byte
+				// map keys, overflowing the goroutine stack (384 bytes).
+				continue
+
 			case "gc.go":
 				// Does not pass due to high mark false positive rate.
 				continue
@@ -451,7 +473,7 @@ func runTestWithConfig(name string, t *testing.T, options compileopts.Options, c
 
 	// Build the test binary.
 	stdout := &bytes.Buffer{}
-	_, err = buildAndRun(pkgName, config, stdout, cmdArgs, environmentVars, time.Minute, func(cmd *exec.Cmd, result builder.BuildResult) error {
+	_, err = buildAndRun(pkgName, config, stdout, cmdArgs, environmentVars, 2*time.Minute, func(cmd *exec.Cmd, result builder.BuildResult) error {
 		return cmd.Run()
 	})
 	if err != nil {

src/crypto/internal/entropy/v1.0.0/entropy.go

@@ -0,0 +1,56 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Stripped-down version of the entropy package for TinyGo.
+//
+// The upstream Go 1.26 package allocates a [1<<25]byte (32 MiB) global buffer
+// for CPU jitter-based SP 800-90B entropy collection. This is fine on systems
+// with virtual memory where BSS pages are lazily backed, but it causes a fatal
+// "RAM overflowed" error on microcontrollers and other memory-constrained
+// targets.
+//
+// Because FIPS 140-3 jitter entropy is never used on TinyGo targets (the DRBG
+// falls through to sysrand.Read when fips140.Enabled is false), this overlay
+// replaces the 32 MiB buffer with a zero-size type.
+package entropy
+
+// Version returns the version of the entropy source.
+func Version() string {
+	return "v1.0.0"
+}
+
+// ScratchBuffer is a large buffer in upstream Go (32 MiB). TinyGo replaces it
+// with a zero-size type since the CPU jitter entropy source is not used.
+type ScratchBuffer [0]byte
+
+// Seed returns a 384-bit seed with full entropy.
+// On TinyGo targets this is never called because FIPS mode is not enabled.
+func Seed(memory *ScratchBuffer) ([48]byte, error) {
+	panic("entropy: CPU jitter entropy source is not supported on TinyGo targets")
+}
+
+// Samples collects entropy samples. Not supported on TinyGo targets.
+func Samples(samples []uint8, memory *ScratchBuffer) error {
+	panic("entropy: CPU jitter entropy source is not supported on TinyGo targets")
+}
+
+// SHA384 computes SHA-384 over 1024 bytes. Not supported on TinyGo targets.
+func SHA384(p *[1024]byte) [48]byte {
+	panic("entropy: CPU jitter entropy source is not supported on TinyGo targets")
+}
+
+// TestingOnlySHA384 computes SHA-384 over arbitrary bytes. Not supported on TinyGo targets.
+func TestingOnlySHA384(p []byte) [48]byte {
+	panic("entropy: CPU jitter entropy source is not supported on TinyGo targets")
+}
+
+// RepetitionCountTest implements the repetition count test from SP 800-90B.
+func RepetitionCountTest(samples []uint8) error {
+	panic("entropy: CPU jitter entropy source is not supported on TinyGo targets")
+}
+
+// AdaptiveProportionTest implements the adaptive proportion test from SP 800-90B.
+func AdaptiveProportionTest(samples []uint8) error {
+	panic("entropy: CPU jitter entropy source is not supported on TinyGo targets")
+}

src/crypto/rand/rand_baremetal.go

@@ -1,4 +1,4 @@
-//go:build nrf || (stm32 && !(stm32f103 || stm32l0x1)) || (sam && atsamd51) || (sam && atsame5x) || esp32c3 || tkey || (tinygo.riscv32 && virt)
+//go:build nrf || (stm32 && !(stm32f103 || stm32l0x1)) || (sam && atsamd51) || (sam && atsame5x) || esp32c3 || esp32s3 || tkey || (tinygo.riscv32 && virt)
 
 // If you update the above build constraint, you'll probably also need to update
 // src/runtime/rand_hwrng.go.

src/device/esp/esp32s3.S

@@ -0,0 +1,397 @@
+// Startup code for the ESP32-S3 (Xtensa LX7, windowed ABI).
+//
+// The ROM bootloader loads IRAM/DRAM segments into SRAM but does NOT
+// configure flash cache/MMU.  We must:
+//   1. Set up the windowed-ABI register file and stack pointer.
+//   2. Set VECBASE and clear PS.EXCM (needed for callx4 window overflows).
+//   3. Disable watchdog timers.
+//   4. Configure the flash cache and MMU so IROM/DROM are accessible.
+//   5. Jump to runtime.main (in IROM).
+//
+// Cache/MMU init sequence (from NuttX esp_loader.c / ESP-IDF bootloader / esp-hal):
+//   Phase A — configure cache modes:
+//     a. rom_config_instruction_cache_mode(16KB, 8-way, 32B)
+//     b. rom_Cache_Suspend_DCache()
+//     c. rom_config_data_cache_mode(32KB, 8-way, 32B)
+//     d. Cache_Resume_DCache(0)
+//   Phase B — map flash pages:
+//     e. Disable caches
+//     f. Cache_MMU_Init() — reset all MMU entries to invalid
+//     g. Cache_Set_IDROM_MMU_Size() — set IROM/DROM entry split
+//     h. Write MMU entries mapping flash page 0 for IROM and DROM
+//     i. Clear bus-shut bits
+//     j. Enable caches + isync
+
+#define PS_WOE   0x00040000
+
+// -----------------------------------------------------------------------
+// Boot entry point — placed in IRAM by the linker.
+// -----------------------------------------------------------------------
+.section .text.call_start_cpu0
+    .literal_position
+    .align 4
+.Lstack_top_addr:
+    .long _stack_top
+.Lmain_addr:
+    .long main
+.Lvector_table_addr:
+    .long _vector_table
+// WDT register addresses
+.Lwdt_key:
+    .long 0x50D83AA1
+.Lrtc_wdt_protect:
+    .long 0x600080B0
+.Lrtc_wdt_config0:
+    .long 0x60008098
+.Ltimg0_wdt_protect:
+    .long 0x6001F064
+.Ltimg0_wdt_config0:
+    .long 0x6001F048
+.Ltimg1_wdt_protect:
+    .long 0x60020064
+.Ltimg1_wdt_config0:
+    .long 0x60020048
+.Lswd_protect:
+    .long 0x600080B8
+.Lswd_key:
+    .long 0x8F1D312A
+.Lswd_conf:
+    .long 0x600080B4
+.Lswd_disable:
+    .long 0x40000000
+// ROM function addresses (from ESP-IDF esp32s3.rom.ld)
+.Lrom_config_icache:
+    .long 0x40001a1c
+.Lrom_config_dcache:
+    .long 0x40001a28
+.Lrom_suspend_dcache:
+    .long 0x400018b4
+.LCache_Resume_DCache:
+    .long 0x400018c0
+.LCache_Disable_ICache:
+    .long 0x4000186c
+.LCache_Disable_DCache:
+    .long 0x40001884
+.LCache_MMU_Init:
+    .long 0x40001998
+.LCache_Set_IDROM_MMU_Size:
+    .long 0x40001914
+.LCache_Enable_ICache:
+    .long 0x40001878
+.LCache_Enable_DCache:
+    .long 0x40001890
+// Cache/MMU register addresses
+.Lmmu_table_base:
+    .long 0x600C5000
+.Licache_ctrl1_reg:
+    .long 0x600C4064
+.Ldcache_ctrl1_reg:
+    .long 0x600C4004
+// End-of-section symbols for multi-page MMU mapping.
+.Lirom_end:
+    .long _irom_end
+.Ldrom_end:
+    .long _drom_end
+.Lirom_base:
+    .long 0x42000000
+.Ldrom_base:
+    .long 0x3C000000
+
+.global call_start_cpu0
+call_start_cpu0:
+
+    // ---- 1. Windowed-ABI register file setup ----
+
+    // Disable WOE so we can safely manipulate WINDOWSTART.
+    rsr.ps a2
+    movi a3, ~(PS_WOE)
+    and a2, a2, a3
+    wsr.ps a2
+    rsync
+
+    // Set WINDOWSTART to 1 << WINDOWBASE (mark only current window as valid).
+    rsr.windowbase  a2
+    ssl  a2
+    movi a2, 1
+    sll  a2, a2
+    wsr.windowstart a2
+    rsync
+
+    // Load stack pointer.
+    l32r a1, .Lstack_top_addr
+
+    // Re-enable WOE.
+    rsr.ps a2
+    movi a3, PS_WOE
+    or a2, a2, a3
+    wsr.ps a2
+    rsync
+
+    // Enable FPU (coprocessor 0).
+    movi a2, 1
+    wsr.cpenable a2
+    rsync
+
+    // ---- 2. Disable all watchdog timers (IMMEDIATELY, before any delay) ----
+    l32r a3, .Lwdt_key
+    movi a4, 0
+
+    // RTC WDT
+    l32r a2, .Lrtc_wdt_protect
+    memw
+    s32i a3, a2, 0
+    l32r a5, .Lrtc_wdt_config0
+    memw
+    s32i a4, a5, 0
+    memw
+    s32i a4, a2, 0
+
+    // TIMG0 WDT
+    l32r a2, .Ltimg0_wdt_protect
+    memw
+    s32i a3, a2, 0
+    l32r a5, .Ltimg0_wdt_config0
+    memw
+    s32i a4, a5, 0
+    memw
+    s32i a4, a2, 0
+
+    // TIMG1 WDT
+    l32r a2, .Ltimg1_wdt_protect
+    memw
+    s32i a3, a2, 0
+    l32r a5, .Ltimg1_wdt_config0
+    memw
+    s32i a4, a5, 0
+    memw
+    s32i a4, a2, 0
+
+    // Super WDT
+    l32r a2, .Lswd_protect
+    l32r a3, .Lswd_key
+    memw
+    s32i a3, a2, 0
+    l32r a5, .Lswd_conf
+    l32r a6, .Lswd_disable
+    memw
+    s32i a6, a5, 0
+    memw
+    s32i a4, a2, 0
+
+    // ---- 3. Set VECBASE and clear PS.EXCM ----
+    // VECBASE must be set before any callx4 so that window overflow
+    // exceptions (triggered by register window rotation) route to our
+    // handlers in IRAM, not the ROM's default vectors.
+    l32r a8, .Lvector_table_addr
+    wsr.vecbase a8
+    rsync
+
+    // Clear PS.EXCM (bit 4) and PS.INTLEVEL (bits 0-3).
+    // The ROM bootloader may leave EXCM=1; with EXCM set any callx4
+    // window overflow would become a double exception.
+    // Set PS.UM (bit 5) so level-1 exceptions route to User vector.
+    rsr.ps a2
+    movi a3, ~0x1F
+    and a2, a2, a3
+    movi a3, 0x20
+    or a2, a2, a3
+    wsr.ps a2
+    rsync
+
+    // ---- 4. Configure flash cache and MMU ----
+    //
+    // ROM function calls use callx4 (windowed ABI):
+    //   a4 = target address (overwritten with return addr by call mechanism)
+    //   a5 = stack pointer for callee (becomes callee's a1 via entry)
+    //   a6 = first argument  (becomes callee's a2)
+    //   a7 = second argument (becomes callee's a3)
+    //   a8 = third argument  (becomes callee's a4)
+    // Registers a0-a3 are preserved across callx4; a4-a11 may be clobbered.
+
+    // Phase A: Configure cache modes (required for cache hardware to function).
+    // Without this, the cache doesn't know its size/associativity/line-size
+    // and cannot service flash accesses.
+
+    // 4a. Configure ICache mode: 16KB, 8-way, 32-byte line
+    movi a6, 0x4000         // cache_size = 16KB
+    movi a7, 8              // ways = 8
+    movi a8, 32             // line_size = 32
+    mov  a5, a1
+    l32r a4, .Lrom_config_icache
+    callx4 a4
+
+    // 4b. Suspend DCache before configuring it
+    mov  a5, a1
+    l32r a4, .Lrom_suspend_dcache
+    callx4 a4
+
+    // 4c. Configure DCache mode: 32KB, 8-way, 32-byte line
+    movi a6, 0x8000         // cache_size = 32KB
+    movi a7, 8              // ways = 8
+    movi a8, 32             // line_size = 32
+    mov  a5, a1
+    l32r a4, .Lrom_config_dcache
+    callx4 a4
+
+    // 4d. Resume DCache
+    movi a6, 0
+    mov  a5, a1
+    l32r a4, .LCache_Resume_DCache
+    callx4 a4
+
+    // Phase B: Map flash pages into MMU.
+
+    // 4e. Disable ICache
+    mov  a5, a1
+    l32r a4, .LCache_Disable_ICache
+    callx4 a4
+
+    // 4f. Disable DCache
+    mov  a5, a1
+    l32r a4, .LCache_Disable_DCache
+    callx4 a4
+
+    // 4g. Initialize MMU (resets all 512 entries to invalid = 0x4000)
+    mov  a5, a1
+    l32r a4, .LCache_MMU_Init
+    callx4 a4
+
+    // 4h. Set IDROM MMU size: even 256/256 split.
+    //     Each entry is 4 bytes, so 256 entries = 0x400 bytes per region.
+    movi a6, 0x400          // irom_mmu_size  (256 entries × 4 bytes)
+    movi a7, 0x400          // drom_mmu_size  (256 entries × 4 bytes)
+    mov  a5, a1
+    l32r a4, .LCache_Set_IDROM_MMU_Size
+    callx4 a4
+
+    // 4i. Map flash pages for IROM and DROM using identity mapping.
+    //     MMU table at 0x600C5000: entries 0-255 = ICache, 256-511 = DCache.
+    //     Entry value N = flash page N (SOC_MMU_VALID = 0 on S3).
+    //     Each 64KB page needs one 4-byte entry.
+    //
+    //     IROM: map pages 0..N where N = (_irom_end - 0x42000000) >> 16
+    //     DROM: map pages 0..M where M = (_drom_end - 0x3C000000) >> 16
+
+    l32r a8, .Lmmu_table_base          // a8 = 0x600C5000
+
+    // --- IROM pages ---
+    l32r a2, .Lirom_end                // a2 = _irom_end (VMA in 0x42xxxxxx)
+    l32r a3, .Lirom_base               // a3 = 0x42000000
+    sub  a2, a2, a3                    // a2 = byte offset past IROM base
+    srli a2, a2, 16                    // a2 = last page index
+    addi a2, a2, 1                     // a2 = number of pages to map
+    movi a9, 0                         // a9 = page counter (and entry value)
+    mov  a10, a8                       // a10 = current MMU entry pointer
+.Lirom_loop:
+    s32i a9, a10, 0
+    addi a9, a9, 1
+    addi a10, a10, 4
+    blt  a9, a2, .Lirom_loop
+
+    // --- DROM pages ---
+    l32r a2, .Ldrom_end                // a2 = _drom_end (VMA in 0x3Cxxxxxx)
+    l32r a3, .Ldrom_base               // a3 = 0x3C000000
+    sub  a2, a2, a3                    // a2 = byte offset past DROM base
+    srli a2, a2, 16                    // a2 = last page index
+    addi a2, a2, 1                     // a2 = number of pages to map
+    movi a9, 0                         // a9 = page counter (and entry value)
+    addmi a10, a8, 0x400              // a10 = 0x600C5400 (DCache entry 256)
+.Ldrom_loop:
+    s32i a9, a10, 0
+    addi a9, a9, 1
+    addi a10, a10, 4
+    blt  a9, a2, .Ldrom_loop
+    memw
+
+    // 4j. Clear bus-shut bits so core 0 can access ICache and DCache buses.
+    l32r a8, .Licache_ctrl1_reg         // 0x600C4064
+    movi a9, 0
+    s32i a9, a8, 0                      // Clear all ICACHE_CTRL1 shut bits
+    l32r a8, .Ldcache_ctrl1_reg         // 0x600C4004
+    s32i a9, a8, 0                      // Clear all DCACHE_CTRL1 shut bits
+    memw
+
+    // 4k. Enable ICache (arg: autoload = 0)
+    movi a6, 0
+    mov  a5, a1
+    l32r a4, .LCache_Enable_ICache
+    callx4 a4
+
+    // 4l. Enable DCache (arg: autoload = 0)
+    movi a6, 0
+    mov  a5, a1
+    l32r a4, .LCache_Enable_DCache
+    callx4 a4
+
+    // Flush instruction pipeline so new cache/MMU config takes effect.
+    isync
+
+    // ---- 5. Jump to main (in IROM) ----
+    // Re-clear PS.EXCM in case ROM calls changed processor state.
+    rsr.ps a2
+    movi a3, ~0x1F
+    and a2, a2, a3
+    movi a3, 0x20
+    or a2, a2, a3
+    wsr.ps a2
+    rsync
+
+    mov  a5, a1
+    l32r a4, .Lmain_addr
+    callx4 a4
+
+    // If main returns, loop forever.
+1:  j 1b
+
+// -----------------------------------------------------------------------
+// tinygo_scanCurrentStack — Spill all Xtensa register windows to the
+// stack, then call tinygo_scanstack(sp) so the conservative GC can
+// discover live heap pointers that are currently in physical registers.
+//
+// On RISC-V / ARM the equivalent function pushes callee-saved registers
+// before the call.  On Xtensa windowed ABI the same effect is achieved
+// by forcing hardware window-overflow for every occupied pane: each
+// overflow saves the four registers in that pane to the stack frame
+// pointed to by the pane's a1 (sp).  After all panes are flushed, a
+// scan from the current sp to stackTop covers every live value.
+// -----------------------------------------------------------------------
+.section .text.tinygo_scanCurrentStack
+
+.global tinygo_scanCurrentStack
+tinygo_scanCurrentStack:
+    entry a1, 48
+
+    // Disable interrupts while flushing register windows.
+    rsr   a4, PS
+    s32i  a4, a1, 0         // save PS for later restore
+    rsil  a4, 3             // XCHAL_EXCM_LEVEL
+
+    // Flush all register windows using recursive call4.
+    // For NAREG=64 (16 panes), 15 recursive levels cover all panes
+    // except the current one (which is kept active).
+    movi a6, 15
+    call4 .Lscan_spill
+
+    // Restore interrupts.
+    l32i  a4, a1, 0
+    wsr.ps a4
+    rsync
+
+    // Pass current sp to tinygo_scanstack.
+    // call4 maps caller's a5→callee's a1 (stack ptr for callee's entry)
+    // and caller's a6→callee's a2 (first argument = sp).
+    mov  a5, a1             // callee's a1 = valid stack pointer
+    mov  a6, a1             // callee's a2 = sp argument
+    call4 tinygo_scanstack
+
+    retw
+
+    .balign 4
+.Lscan_spill:
+    entry a1, 16
+    beqz  a2, .Lscan_spill_done
+    addi  a2, a2, -1
+    mov   a6, a2
+    call4 .Lscan_spill
+.Lscan_spill_done:
+    retw

src/device/riscv/handleinterrupt.S

@@ -75,6 +75,10 @@ handleInterruptASM:
     SFREG   f30,(30 + 16)*REGSIZE(sp)
     SFREG   f31,(31 + 16)*REGSIZE(sp)
 #endif
+    // Save ra to a global so handleException can print the caller of the NULL
+    // function pointer.
+    la      t0, tinygo_saved_ra
+    SREG    ra, 0(t0)
     call    handleInterrupt
 #ifdef __riscv_flen
     LFREG   f0, (31 + 16)*REGSIZE(sp)
@@ -128,3 +132,10 @@ handleInterruptASM:
     LREG    ra, 0*REGSIZE(sp)
     addi    sp, sp, NREG*REGSIZE
     mret
+
+.section .bss.tinygo_saved_ra
+.global tinygo_saved_ra
+.type tinygo_saved_ra,@object
+.align 2
+tinygo_saved_ra:
+    .space REGSIZE

src/examples/adc/adc.go

@@ -5,25 +5,15 @@ import (
 	"time"
 )
 
-// This example assumes that an analog sensor such as a rotary dial is connected to pin ADC0.
-// When the dial is turned past the midway point, the built-in LED will light up.
-
 func main() {
 	machine.InitADC()
 
-	led := machine.LED
-	led.Configure(machine.PinConfig{Mode: machine.PinOutput})
-
 	sensor := machine.ADC{machine.ADC2}
 	sensor.Configure(machine.ADCConfig{})
 
 	for {
 		val := sensor.Get()
-		if val < 0x8000 {
-			led.Low()
-		} else {
-			led.High()
-		}
-		time.Sleep(time.Millisecond * 100)
+		println(val)
+		time.Sleep(time.Millisecond * 500)
 	}
 }

src/examples/pininterrupt/arduino-uno.go

@@ -1,4 +1,4 @@
-//go:build arduino
+//go:build arduino_uno
 
 package main
 

src/examples/pininterrupt/xiao-esp32s3.go

@@ -0,0 +1,11 @@
+//go:build xiao_esp32s3
+
+package main
+
+import "machine"
+
+const (
+	button          = machine.D1
+	buttonMode      = machine.PinInputPullup
+	buttonPinChange = machine.PinFalling
+)

src/examples/pwm/arduino-uno-q.go

@@ -0,0 +1,11 @@
+//go:build arduino_uno_q
+
+package main
+
+import "machine"
+
+var (
+	pwm  = &machine.TIM3
+	pinA = machine.D3 // PB0 = TIM3_CH3
+	pinB = machine.D6 // PB1 = TIM3_CH4
+)

src/examples/pwm/arduino-uno.go

@@ -1,4 +1,4 @@
-//go:build arduino
+//go:build arduino_uno
 
 package main
 

src/examples/pwm/digispark.go

@@ -0,0 +1,12 @@
+//go:build digispark
+
+package main
+
+import "machine"
+
+var (
+	// Use Timer1 for PWM (recommended for ATtiny85)
+	pwm  = machine.Timer1
+	pinA = machine.P1 // PB1, Timer1 channel A (LED pin)
+	pinB = machine.P4 // PB4, Timer1 channel B
+)

src/examples/pwm/esp32c3-supermini.go

@@ -0,0 +1,11 @@
+//go:build esp32c3_supermini
+
+package main
+
+import "machine"
+
+var (
+	pwm  = machine.PWM0
+	pinA = machine.GPIO5
+	pinB = machine.GPIO6
+)

src/examples/pwm/pico2.go

@@ -0,0 +1,11 @@
+//go:build pico2 || pico_plus2
+
+package main
+
+import "machine"
+
+var (
+	pwm = machine.PWM0 // Pin 25 (LED on pico2) corresponds to PWM0.
+	//pinA = machine.LED
+	pinA = machine.GPIO16
+)

src/examples/pwm/xiao_esp32s3.go

@@ -0,0 +1,11 @@
+//go:build xiao_esp32s3
+
+package main
+
+import "machine"
+
+var (
+	pwm  = machine.PWM0
+	pinA = machine.D0
+	pinB = machine.D1
+)

src/examples/serial-stress/main.go

@@ -0,0 +1,29 @@
+package main
+
+import (
+	"machine"
+	"strconv"
+	"time"
+)
+
+func main() {
+	time.Sleep(2 * time.Second) // connect via serial
+	buf1 := makeBuffer('|', 600)
+	buf2 := makeBuffer('/', 600)
+	println("start")
+	serialWrite(buf1)
+	serialWrite(buf2)
+}
+
+func makeBuffer(sep byte, size int) []byte {
+	buf := make([]byte, size)
+	for i := 0; i < size-5; i += 5 {
+		buf[i] = sep
+		strconv.AppendInt(buf[i+1:i+1:i+5], int64(i), 10)
+	}
+	return buf
+}
+
+func serialWrite(b []byte) {
+	machine.Serial.Write(b)
+}

src/internal/abi/escape.go

@@ -15,3 +15,35 @@ func Escape[T any](x T) T {
 	// as-is.
 	panic("internal/abi.Escape: unreachable (implemented in the compiler)")
 }
+
+// EscapeNonString forces v to be on the heap, if v contains a
+// non-string pointer.
+//
+// This is used in hash/maphash.Comparable. We cannot hash pointers
+// to local variables on stack, as their addresses might change on
+// stack growth. Strings are okay as the hash depends on only the
+// content, not the pointer.
+//
+// This is essentially
+//
+//	if hasNonStringPointers(T) { Escape(v) }
+//
+// Implemented as a compiler intrinsic.
+func EscapeNonString[T any](v T) { panic("intrinsic") }
+
+// EscapeToResultNonString models a data flow edge from v to the result,
+// if v contains a non-string pointer. If v contains only string pointers,
+// it returns a copy of v, but is not modeled as a data flow edge
+// from the escape analysis's perspective.
+//
+// This is used in unique.clone, to model the data flow edge on the
+// value with strings excluded, because strings are cloned (by
+// content).
+//
+// TODO: probably we should define this as a intrinsic and EscapeNonString
+// could just be "heap = EscapeToResultNonString(v)". This way we can model
+// an edge to the result but not necessarily heap.
+func EscapeToResultNonString[T any](v T) T {
+	EscapeNonString(v)
+	return *(*T)(NoEscape(unsafe.Pointer(&v)))
+}

src/internal/itoa/itoa.go

@@ -0,0 +1,57 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Simple conversions to avoid depending on strconv.
+
+package itoa
+
+// Itoa converts val to a decimal string.
+func Itoa(val int) string {
+	if val < 0 {
+		return "-" + Uitoa(uint(-val))
+	}
+	return Uitoa(uint(val))
+}
+
+// Uitoa converts val to a decimal string.
+func Uitoa(val uint) string {
+	if val == 0 { // avoid string allocation
+		return "0"
+	}
+	var buf [20]byte // big enough for 64bit value base 10
+	i := len(buf) - 1
+	for val >= 10 {
+		q := val / 10
+		buf[i] = byte('0' + val - q*10)
+		i--
+		val = q
+	}
+	// val < 10
+	buf[i] = byte('0' + val)
+	return string(buf[i:])
+}
+
+const hex = "0123456789abcdef"
+
+// Uitox converts val (a uint) to a hexadecimal string.
+func Uitox(val uint) string {
+	if val == 0 { // avoid string allocation
+		return "0x0"
+	}
+	var buf [20]byte // big enough for 64bit value base 16 + 0x
+	i := len(buf) - 1
+	for val >= 16 {
+		q := val / 16
+		buf[i] = hex[val%16]
+		i--
+		val = q
+	}
+	// val < 16
+	buf[i] = hex[val%16]
+	i--
+	buf[i] = 'x'
+	i--
+	buf[i] = '0'
+	return string(buf[i:])
+}

src/internal/itoa/itoa_test.go

@@ -0,0 +1,51 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package itoa_test
+
+import (
+	"fmt"
+	"internal/itoa"
+	"math"
+	"testing"
+)
+
+var (
+	minInt64  int64  = math.MinInt64
+	maxInt64  int64  = math.MaxInt64
+	maxUint64 uint64 = math.MaxUint64
+)
+
+func TestItoa(t *testing.T) {
+	tests := []int{int(minInt64), math.MinInt32, -999, -100, -1, 0, 1, 100, 999, math.MaxInt32, int(maxInt64)}
+	for _, tt := range tests {
+		got := itoa.Itoa(tt)
+		want := fmt.Sprint(tt)
+		if want != got {
+			t.Fatalf("Itoa(%d) = %s, want %s", tt, got, want)
+		}
+	}
+}
+
+func TestUitoa(t *testing.T) {
+	tests := []uint{0, 1, 100, 999, math.MaxUint32, uint(maxUint64)}
+	for _, tt := range tests {
+		got := itoa.Uitoa(tt)
+		want := fmt.Sprint(tt)
+		if want != got {
+			t.Fatalf("Uitoa(%d) = %s, want %s", tt, got, want)
+		}
+	}
+}
+
+func TestUitox(t *testing.T) {
+	tests := []uint{0, 1, 15, 100, 999, math.MaxUint32, uint(maxUint64)}
+	for _, tt := range tests {
+		got := itoa.Uitox(tt)
+		want := fmt.Sprintf("%#x", tt)
+		if want != got {
+			t.Fatalf("Uitox(%x) = %s, want %s", tt, got, want)
+		}
+	}
+}

src/internal/reflectlite/type.go

@@ -157,6 +157,10 @@ const (
 	flagIsBinary   = 128 // flag that is set if this type uses the hashmap binary algorithm
 )
 
+// Flag in the numMethod field (uint16) of Pointer and Struct type descriptors,
+// indicating that an inline method set is present in the type descriptor.
+const numMethodHasMethodSet = 0x8000
+
 // The base type struct. All type structs start with this.
 type RawType struct {
 	meta uint8 // metadata byte, contains kind and flags (see constants above)
@@ -171,16 +175,22 @@ type elemType struct {
 	elem      *RawType
 }
 
+// ptrType is the type descriptor for pointer types.
+// The numMethod field stores the number of exported methods in the lower bits,
+// with bit 15 (numMethodHasMethodSet) indicating whether the methods field is
+// present. When the flag is clear, the methods field does not exist in the
+// actual type descriptor and must not be accessed.
 type ptrType struct {
 	RawType
 	numMethod uint16
 	elem      *RawType
+	methods   methodSet // only present when numMethod & numMethodHasMethodSet != 0
 }
 
 type interfaceType struct {
 	RawType
-	ptrTo *RawType
-	// TODO: methods
+	ptrTo   *RawType
+	methods methodSet
 }
 
 type arrayType struct {
@@ -200,13 +210,19 @@ type mapType struct {
 	key       *RawType
 }
 
+// namedType is the type descriptor for named types. The numMethod field uses
+// bit 15 (numMethodHasMethodSet) to indicate whether an inline method set is
+// present after pkg. When the flag is set, a methodSet follows at
+// unsafe.Sizeof(namedType{}), and the name string follows after the method
+// set's entries. When clear, the name string starts directly at that offset.
 type namedType struct {
 	RawType
 	numMethod uint16
 	ptrTo     *RawType
 	elem      *RawType
 	pkg       *byte
-	name      [1]byte
+	// if numMethod & numMethodHasMethodSet != 0: methodSet follows here
+	// name (null-terminated "pkg.Name\0") follows after the method set (or directly here)
 }
 
 // Type for struct types. The numField value is intentionally put before ptrTo
@@ -216,6 +232,10 @@ type namedType struct {
 // The fields array isn't necessarily 1 structField long, instead it is as long
 // as numFields. The array is given a length of 1 to satisfy the Go type
 // checker.
+// The numMethod field stores the number of exported methods in the lower bits,
+// with bit 15 (numMethodHasMethodSet) indicating whether an inline method set
+// follows the fields array. When the flag is clear, no method set is present
+// and the type descriptor ends after the last structField entry.
 type structType struct {
 	RawType
 	numMethod uint16
@@ -224,6 +244,7 @@ type structType struct {
 	size      uint32
 	numField  uint16
 	fields    [1]structField // the remaining fields are all of type structField
+	// methods methodSet follows after fields, only when numMethod & numMethodHasMethodSet != 0
 }
 
 type structField struct {
@@ -231,6 +252,12 @@ type structField struct {
 	data      unsafe.Pointer // various bits of information, packed in a byte array
 }
 
+// Method set, as emitted by the compiler.
+type methodSet struct {
+	length  uintptr
+	methods [0]unsafe.Pointer // variable number of method signature pointers
+}
+
 // Equivalent to (go/types.Type).Underlying(): if this is a named type return
 // the underlying type, else just return the type itself.
 func (t *RawType) underlying() *RawType {
@@ -426,10 +453,7 @@ func rawStructFieldFromPointer(descriptor *structType, fieldType *RawType, data
 		data = unsafe.Add(data, 1) // C: data+1
 		tagLen := uintptr(*(*byte)(data))
 		data = unsafe.Add(data, 1) // C: data+1
-		tag = *(*string)(unsafe.Pointer(&stringHeader{
-			data: data,
-			len:  tagLen,
-		}))
+		tag = unsafe.String((*byte)(data), tagLen)
 	}
 
 	// Set the PkgPath to some (arbitrary) value if the package path is not
@@ -733,21 +757,38 @@ func (t *RawType) FieldAlign() int {
 // AssignableTo returns whether a value of type t can be assigned to a variable
 // of type u.
 func (t *RawType) AssignableTo(u Type) bool {
-	if t == u.(*RawType) {
-		return true
-	}
-
-	if t.underlying() == u.(*RawType).underlying() && (!t.isNamed() || !u.(*RawType).isNamed()) {
-		return true
-	}
-
-	if u.Kind() == Interface && u.NumMethod() == 0 {
+	u_raw := u.(*RawType)
+	if t == u_raw {
 		return true
 	}
 
 	if u.Kind() == Interface {
-		panic("reflect: unimplemented: AssignableTo with interface")
+		// T is an interface type and x implements T.
+		u_itf := (*interfaceType)(unsafe.Pointer(u_raw.underlying()))
+		return typeImplementsMethodSet(unsafe.Pointer(t), unsafe.Pointer(&u_itf.methods))
 	}
+
+	t_named := t.isNamed()
+	u_named := u_raw.isNamed()
+	if t_named && u_named {
+		return false
+	}
+	if t.underlying() == u_raw.underlying() {
+		return true
+	}
+
+	if t.Kind() == Chan && u_raw.Kind() == Chan {
+		t_chan := (*elemType)(unsafe.Pointer(t.underlying()))
+		u_chan := (*elemType)(unsafe.Pointer(u_raw.underlying()))
+		if t_chan.elem != u_chan.elem {
+			return false
+		}
+		if t_chan.ChanDir() != BothDir {
+			return false
+		}
+		return true
+	}
+
 	return false
 }
 
@@ -755,7 +796,85 @@ func (t *RawType) Implements(u Type) bool {
 	if u.Kind() != Interface {
 		panic("reflect: non-interface type passed to Type.Implements")
 	}
-	return t.AssignableTo(u)
+	u_itf := (*interfaceType)(unsafe.Pointer(u.(*RawType).underlying()))
+	return typeImplementsMethodSet(unsafe.Pointer(t), unsafe.Pointer(&u_itf.methods))
+}
+
+// typeImplementsMethodSet checks whether the concrete type (identified by its
+// typecode pointer) implements the given method set. Both the concrete type's
+// method set and the asserted method set are sorted arrays of method signature
+// pointers, so comparison is O(n+m).
+//
+//go:linkname typeImplementsMethodSet runtime.typeImplementsMethodSet
+func typeImplementsMethodSet(concreteType, assertedMethodSet unsafe.Pointer) bool {
+	if concreteType == nil {
+		return false
+	}
+
+	const ptrSize = unsafe.Sizeof((*byte)(nil))
+	itfNumMethod := *(*uintptr)(assertedMethodSet)
+	if itfNumMethod == 0 {
+		return true
+	}
+
+	// Pull the method set out of the concrete type.
+	var methods *methodSet
+	metaByte := *(*uint8)(concreteType)
+	if metaByte&flagNamed != 0 {
+		ct := (*namedType)(concreteType)
+		if ct.numMethod&numMethodHasMethodSet == 0 {
+			return false
+		}
+		methods = (*methodSet)(unsafe.Add(unsafe.Pointer(ct), unsafe.Sizeof(*ct)))
+	} else if metaByte&kindMask == uint8(Interface) {
+		ct := (*interfaceType)(concreteType)
+		methods = &ct.methods
+	} else if metaByte&kindMask == uint8(Pointer) {
+		ct := (*ptrType)(concreteType)
+		if ct.numMethod&numMethodHasMethodSet == 0 {
+			return false
+		}
+		methods = &ct.methods
+	} else if metaByte&kindMask == uint8(Struct) {
+		ct := (*structType)(concreteType)
+		if ct.numMethod&numMethodHasMethodSet == 0 {
+			return false
+		}
+		// For struct types, the method set follows after the variable-length
+		// fields array. We need to compute its offset dynamically.
+		fieldSize := unsafe.Sizeof(structField{})
+		methodsPtr := unsafe.Add(unsafe.Pointer(&ct.fields[0]), uintptr(ct.numField)*fieldSize)
+		methods = (*methodSet)(methodsPtr)
+	} else {
+		return false
+	}
+
+	concreteTypePtr := unsafe.Pointer(&methods.methods)
+	concreteTypeEnd := unsafe.Add(concreteTypePtr, uintptr(methods.length)*ptrSize)
+
+	// Iterate over each method in the interface method set, and check whether
+	// the method exists in the method set of the concrete type.
+	// Both method sets are sorted, so we can use a linear scan.
+	assertedTypePtr := unsafe.Add(assertedMethodSet, ptrSize)
+	assertedTypeEnd := unsafe.Add(assertedTypePtr, itfNumMethod*ptrSize)
+	for assertedTypePtr != assertedTypeEnd {
+		assertedMethod := *(*unsafe.Pointer)(assertedTypePtr)
+
+		for {
+			if concreteTypePtr == concreteTypeEnd {
+				return false
+			}
+			concreteMethod := *(*unsafe.Pointer)(concreteTypePtr)
+			concreteTypePtr = unsafe.Add(concreteTypePtr, ptrSize)
+			if concreteMethod == assertedMethod {
+				break
+			}
+		}
+
+		assertedTypePtr = unsafe.Add(assertedTypePtr, ptrSize)
+	}
+
+	return true
 }
 
 // Comparable returns whether values of this type can be compared to each other.
@@ -782,14 +901,14 @@ func (t *RawType) ChanDir() ChanDir {
 func (t *RawType) NumMethod() int {
 
 	if t.isNamed() {
-		return int((*namedType)(unsafe.Pointer(t)).numMethod)
+		return int((*namedType)(unsafe.Pointer(t)).numMethod & ^uint16(numMethodHasMethodSet))
 	}
 
 	switch t.Kind() {
 	case Pointer:
-		return int((*ptrType)(unsafe.Pointer(t)).numMethod)
+		return int((*ptrType)(unsafe.Pointer(t)).numMethod & ^uint16(numMethodHasMethodSet))
 	case Struct:
-		return int((*structType)(unsafe.Pointer(t)).numMethod)
+		return int((*structType)(unsafe.Pointer(t)).numMethod & ^uint16(numMethodHasMethodSet))
 	case Interface:
 		//FIXME: Use len(methods)
 		return (*interfaceType)(unsafe.Pointer(t)).ptrTo.NumMethod()
@@ -808,15 +927,19 @@ func readStringZ(data unsafe.Pointer) string {
 		data = unsafe.Add(data, 1) // C: data++
 	}
 
-	return *(*string)(unsafe.Pointer(&stringHeader{
-		data: start,
-		len:  len,
-	}))
+	return unsafe.String((*byte)(start), len)
 }
 
 func (t *RawType) name() string {
 	ntype := (*namedType)(unsafe.Pointer(t))
-	return readStringZ(unsafe.Pointer(&ntype.name[0]))
+	// The name follows after the fixed fields (and optionally the method set).
+	ptr := unsafe.Add(unsafe.Pointer(ntype), unsafe.Sizeof(*ntype))
+	if ntype.numMethod&numMethodHasMethodSet != 0 {
+		ms := (*methodSet)(ptr)
+		// Skip past the length field and the method pointer entries.
+		ptr = unsafe.Add(ptr, unsafe.Sizeof(uintptr(0))+uintptr(ms.length)*unsafe.Sizeof(unsafe.Pointer(nil)))
+	}
+	return readStringZ(ptr)
 }
 
 func (t *RawType) Name() string {

src/internal/reflectlite/value.go

@@ -138,7 +138,7 @@ func TypeAssert[T any](v Value) (T, bool) {
 		var zero T
 		return zero, false
 	}
-	if !v.isIndirect() {
+	if !v.isIndirect() && v.typecode.Size() <= unsafe.Sizeof(uintptr(0)) {
 		return *(*T)(unsafe.Pointer(&v.value)), true
 	}
 	return *(*T)(v.value), true
@@ -146,6 +146,19 @@ func TypeAssert[T any](v Value) (T, bool) {
 
 // valueInterfaceUnsafe is used by the runtime to hash map keys. It should not
 // be subject to the isExported check.
+// loadSmallValue loads a value of size <= sizeof(uintptr) from ptr into
+// a pointer-sized value suitable for storing in an interface's data field.
+func loadSmallValue(ptr unsafe.Pointer, size uintptr) unsafe.Pointer {
+	if size == unsafe.Sizeof(uintptr(0)) {
+		return *(*unsafe.Pointer)(ptr)
+	}
+	var value uintptr
+	for j := size; j != 0; j-- {
+		value = (value << 8) | uintptr(*(*uint8)(unsafe.Add(ptr, j-1)))
+	}
+	return unsafe.Pointer(value)
+}
+
 func valueInterfaceUnsafe(v Value) interface{} {
 	if v.typecode.Kind() == Interface {
 		// The value itself is an interface. This can happen when getting the
@@ -158,11 +171,7 @@ func valueInterfaceUnsafe(v Value) interface{} {
 	if v.isIndirect() && v.typecode.Size() <= unsafe.Sizeof(uintptr(0)) {
 		// Value was indirect but must be put back directly in the interface
 		// value.
-		var value uintptr
-		for j := v.typecode.Size(); j != 0; j-- {
-			value = (value << 8) | uintptr(*(*uint8)(unsafe.Add(v.value, j-1)))
-		}
-		v.value = unsafe.Pointer(value)
+		v.value = loadSmallValue(v.value, v.typecode.Size())
 	}
 	return composeInterface(unsafe.Pointer(v.typecode), v.value)
 }
@@ -713,20 +722,12 @@ func (v Value) Slice(i, j int) Value {
 
 	case String:
 		i, j := uintptr(i), uintptr(j)
-		str := *(*stringHeader)(v.value)
-
-		if j < i || str.len < j {
-			slicePanic()
-		}
-
-		hdr := stringHeader{
-			data: unsafe.Add(str.data, i),
-			len:  j - i,
-		}
+		str := *(*string)(v.value)
+		sliced := str[i:j]
 
 		return Value{
 			typecode: v.typecode,
-			value:    unsafe.Pointer(&hdr),
+			value:    unsafe.Pointer(&sliced),
 			flags:    v.flags,
 		}
 	}
@@ -801,7 +802,7 @@ func (v Value) Len() int {
 	case Slice:
 		return int((*sliceHeader)(v.value).len)
 	case String:
-		return int((*stringHeader)(v.value).len)
+		return len(*(*string)(v.value))
 	default:
 		panic(&ValueError{Method: "Len", Kind: v.Kind()})
 	}
@@ -977,13 +978,10 @@ func (v Value) Index(i int) Value {
 		// Keeping valueFlagExported if set, but don't set valueFlagIndirect
 		// otherwise CanSet will return true for string elements (which is bad,
 		// strings are read-only).
-		s := *(*stringHeader)(v.value)
-		if uint(i) >= uint(s.len) {
-			panic("reflect: string index out of range")
-		}
+		s := *(*string)(v.value)
 		return Value{
 			typecode: uint8Type,
-			value:    unsafe.Pointer(uintptr(*(*uint8)(unsafe.Add(s.data, i)))),
+			value:    unsafe.Pointer(uintptr(s[i])),
 			flags:    v.flags & valueFlagExported,
 		}
 	case Array:
@@ -1085,18 +1083,8 @@ func (v Value) MapKeys() []Value {
 	k := New(v.typecode.Key())
 	e := New(v.typecode.Elem())
 
-	keyType := v.typecode.key()
-	keyTypeIsEmptyInterface := keyType.Kind() == Interface && keyType.NumMethod() == 0
-	shouldUnpackInterface := !keyTypeIsEmptyInterface && keyType.Kind() != String && !keyType.isBinary()
-
 	for hashmapNext(v.pointer(), it, k.value, e.value) {
-		if shouldUnpackInterface {
-			intf := *(*interface{})(k.value)
-			v := ValueOf(intf)
-			keys = append(keys, v)
-		} else {
-			keys = append(keys, k.Elem())
-		}
+		keys = append(keys, k.Elem())
 		k = New(v.typecode.Key())
 	}
 
@@ -1109,9 +1097,40 @@ func hashmapStringGet(m unsafe.Pointer, key string, value unsafe.Pointer, valueS
 //go:linkname hashmapBinaryGet runtime.hashmapBinaryGet
 func hashmapBinaryGet(m unsafe.Pointer, key, value unsafe.Pointer, valueSize uintptr) bool
 
-//go:linkname hashmapInterfaceGet runtime.hashmapInterfaceGet
-func hashmapInterfaceGet(m unsafe.Pointer, key interface{}, value unsafe.Pointer, valueSize uintptr) bool
+//go:linkname hashmapGenericGet runtime.hashmapGenericGet
+func hashmapGenericGet(m unsafe.Pointer, key, value unsafe.Pointer, valueSize uintptr) bool
 
+// genericKeyPtr returns a pointer to key data suitable for passing to the
+// hashmapGeneric* functions. When the map's key type is an interface,
+// special handling is needed: if the key Value already holds an interface
+// (e.g. from MapKeys iteration), its memory already contains the
+// {typecode, data} pair the hashmap expects, so we use it directly.
+// If the key is a concrete type being assigned to an interface-keyed map,
+// we compose the interface first.
+func genericKeyPtr(vkey *RawType, key Value) unsafe.Pointer {
+	if vkey.Kind() == Interface {
+		if key.Kind() == Interface {
+			// Key is already an interface value stored indirectly;
+			// key.value points to {typecode, data}.
+			return key.value
+		}
+		// Concrete value being used as an interface key.
+		// For small addressable values, key.value is a pointer to
+		// the data, but the interface value field stores the data
+		// directly; load it using the same endian-safe approach as
+		// valueInterfaceUnsafe.
+		val := key.value
+		if key.isIndirect() && key.typecode.Size() <= unsafe.Sizeof(uintptr(0)) {
+			val = loadSmallValue(key.value, key.typecode.Size())
+		}
+		intf := composeInterface(unsafe.Pointer(key.typecode), val)
+		return unsafe.Pointer(&intf)
+	}
+	if key.isIndirect() || key.typecode.Size() > unsafe.Sizeof(uintptr(0)) {
+		return key.value
+	}
+	return unsafe.Pointer(&key.value)
+}
 func (v Value) MapIndex(key Value) Value {
 	if v.Kind() != Map {
 		panic(&ValueError{Method: "MapIndex", Kind: v.Kind()})
@@ -1140,13 +1159,16 @@ func (v Value) MapIndex(key Value) Value {
 		} else {
 			keyptr = unsafe.Pointer(&key.value)
 		}
-		//TODO(dgryski): zero out padding bytes in key, if any
 		if ok := hashmapBinaryGet(v.pointer(), keyptr, elem.value, elemType.Size()); !ok {
 			return Value{}
 		}
 		return elem.Elem()
 	} else {
-		if ok := hashmapInterfaceGet(v.pointer(), key.Interface(), elem.value, elemType.Size()); !ok {
+		// Compiler-generated hash/equal path: keys are stored at their
+		// actual type. Use hashmapGenericGet which dispatches through the
+		// map's own keyHash/keyEqual function pointers.
+		keyptr := genericKeyPtr(vkey, key)
+		if ok := hashmapGenericGet(v.pointer(), keyptr, elem.value, elemType.Size()); !ok {
 			return Value{}
 		}
 		return elem.Elem()
@@ -1171,8 +1193,7 @@ type MapIter struct {
 	key Value
 	val Value
 
-	valid              bool
-	unpackKeyInterface bool
+	valid bool
 }
 
 func (it *MapIter) Key() Value {
@@ -1180,12 +1201,6 @@ func (it *MapIter) Key() Value {
 		panic("reflect.MapIter.Key called on invalid iterator")
 	}
 
-	if it.unpackKeyInterface {
-		intf := *(*interface{})(it.key.value)
-		v := ValueOf(intf)
-		return v
-	}
-
 	return it.key.Elem()
 }
 
@@ -1218,15 +1233,9 @@ func (iter *MapIter) Reset(v Value) {
 		panic(&ValueError{Method: "MapRange", Kind: v.Kind()})
 	}
 
-	keyType := v.typecode.key()
-
-	keyTypeIsEmptyInterface := keyType.Kind() == Interface && keyType.NumMethod() == 0
-	shouldUnpackInterface := !keyTypeIsEmptyInterface && keyType.Kind() != String && !keyType.isBinary()
-
 	*iter = MapIter{
-		m:                  v,
-		it:                 hashmapNewIterator(),
-		unpackKeyInterface: shouldUnpackInterface,
+		m:  v,
+		it: hashmapNewIterator(),
 	}
 }
 
@@ -1714,8 +1723,7 @@ const zerobufferLen = 32
 func init() {
 	// 32 characters of zero bytes
 	zerobufferStr := "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
-	s := (*stringHeader)(unsafe.Pointer(&zerobufferStr))
-	zerobuffer = s.data
+	zerobuffer = unsafe.Pointer(unsafe.StringData(zerobufferStr))
 }
 
 func Zero(typ Type) Value {
@@ -1766,19 +1774,11 @@ type sliceHeader struct {
 	cap  uintptr
 }
 
-// Like sliceHeader, this type is used internally to make sure pointer and
-// non-pointer fields match those of actual strings.
-type stringHeader struct {
-	data unsafe.Pointer
-	len  uintptr
-}
-
-// Verify SliceHeader and StringHeader sizes.
+// Verify SliceHeader size.
 // See https://github.com/tinygo-org/tinygo/pull/4156
 // and https://github.com/tinygo-org/tinygo/issues/1284.
 var (
 	_ [unsafe.Sizeof([]byte{})]byte = [unsafe.Sizeof(sliceHeader{})]byte{}
-	_ [unsafe.Sizeof("")]byte       = [unsafe.Sizeof(stringHeader{})]byte{}
 )
 
 type ValueError struct {
@@ -1845,29 +1845,29 @@ func Copy(dst, src Value) int {
 
 func buflen(v Value) (unsafe.Pointer, uintptr) {
 	var buf unsafe.Pointer
-	var len uintptr
+	var length uintptr
 	switch v.typecode.Kind() {
 	case Slice:
 		hdr := (*sliceHeader)(v.value)
 		buf = hdr.data
-		len = hdr.len
+		length = hdr.len
 	case Array:
 		if v.isIndirect() || v.typecode.Size() > unsafe.Sizeof(uintptr(0)) {
 			buf = v.value
 		} else {
 			buf = unsafe.Pointer(&v.value)
 		}
-		len = uintptr(v.Len())
+		length = uintptr(v.Len())
 	case String:
-		hdr := (*stringHeader)(v.value)
-		buf = hdr.data
-		len = hdr.len
+		s := *(*string)(v.value)
+		buf = unsafe.Pointer(unsafe.StringData(s))
+		length = uintptr(len(s))
 	default:
 		// This shouldn't happen
 		panic("reflect.Copy: not slice or array or string")
 	}
 
-	return buf, len
+	return buf, length
 }
 
 //go:linkname sliceGrow runtime.sliceGrow
@@ -1969,8 +1969,8 @@ func hashmapStringSet(m unsafe.Pointer, key string, value unsafe.Pointer)
 //go:linkname hashmapBinarySet runtime.hashmapBinarySet
 func hashmapBinarySet(m unsafe.Pointer, key, value unsafe.Pointer)
 
-//go:linkname hashmapInterfaceSet runtime.hashmapInterfaceSet
-func hashmapInterfaceSet(m unsafe.Pointer, key interface{}, value unsafe.Pointer)
+//go:linkname hashmapGenericSet runtime.hashmapGenericSet
+func hashmapGenericSet(m unsafe.Pointer, key, value unsafe.Pointer)
 
 //go:linkname hashmapStringDelete runtime.hashmapStringDelete
 func hashmapStringDelete(m unsafe.Pointer, key string)
@@ -1978,8 +1978,8 @@ func hashmapStringDelete(m unsafe.Pointer, key string)
 //go:linkname hashmapBinaryDelete runtime.hashmapBinaryDelete
 func hashmapBinaryDelete(m unsafe.Pointer, key unsafe.Pointer)
 
-//go:linkname hashmapInterfaceDelete runtime.hashmapInterfaceDelete
-func hashmapInterfaceDelete(m unsafe.Pointer, key interface{})
+//go:linkname hashmapGenericDelete runtime.hashmapGenericDelete
+func hashmapGenericDelete(m unsafe.Pointer, key unsafe.Pointer)
 
 func (v Value) SetMapIndex(key, elem Value) {
 	v.checkRO()
@@ -2002,15 +2002,19 @@ func (v Value) SetMapIndex(key, elem Value) {
 	}
 
 	// make elem an interface if it needs to be converted
-	if v.typecode.elem().Kind() == Interface && elem.typecode.Kind() != Interface {
-		intf := composeInterface(unsafe.Pointer(elem.typecode), elem.value)
+	if !del && v.typecode.elem().Kind() == Interface && elem.typecode.Kind() != Interface {
+		val := elem.value
+		if elem.isIndirect() && elem.typecode.Size() <= unsafe.Sizeof(uintptr(0)) {
+			val = loadSmallValue(elem.value, elem.typecode.Size())
+		}
+		intf := composeInterface(unsafe.Pointer(elem.typecode), val)
 		elem = Value{
 			typecode: v.typecode.elem(),
 			value:    unsafe.Pointer(&intf),
 		}
 	}
 
-	if key.Kind() == String {
+	if vkey.Kind() == String {
 		if del {
 			hashmapStringDelete(v.pointer(), *(*string)(key.value))
 		} else {
@@ -2023,7 +2027,7 @@ func (v Value) SetMapIndex(key, elem Value) {
 			hashmapStringSet(v.pointer(), *(*string)(key.value), elemptr)
 		}
 
-	} else if key.typecode.isBinary() {
+	} else if vkey.isBinary() {
 		var keyptr unsafe.Pointer
 		if key.isIndirect() || key.typecode.Size() > unsafe.Sizeof(uintptr(0)) {
 			keyptr = key.value
@@ -2043,8 +2047,11 @@ func (v Value) SetMapIndex(key, elem Value) {
 			hashmapBinarySet(v.pointer(), keyptr, elemptr)
 		}
 	} else {
+		// Compiler-generated hash/equal path.
+		keyptr := genericKeyPtr(vkey, key)
+
 		if del {
-			hashmapInterfaceDelete(v.pointer(), key.Interface())
+			hashmapGenericDelete(v.pointer(), keyptr)
 		} else {
 			var elemptr unsafe.Pointer
 			if elem.isIndirect() || elem.typecode.Size() > unsafe.Sizeof(uintptr(0)) {
@@ -2053,7 +2060,7 @@ func (v Value) SetMapIndex(key, elem Value) {
 				elemptr = unsafe.Pointer(&elem.value)
 			}
 
-			hashmapInterfaceSet(v.pointer(), key.Interface(), elemptr)
+			hashmapGenericSet(v.pointer(), keyptr, elemptr)
 		}
 	}
 }
@@ -2110,6 +2117,9 @@ func (v Value) FieldByNameFunc(match func(string) bool) Value {
 //go:linkname hashmapMake runtime.hashmapMake
 func hashmapMake(keySize, valueSize uintptr, sizeHint uintptr, alg uint8) unsafe.Pointer
 
+//go:linkname hashmapMakeReflect runtime.hashmapMakeReflect
+func hashmapMakeReflect(keySize, valueSize, sizeHint uintptr, keyType unsafe.Pointer) unsafe.Pointer
+
 // MakeMapWithSize creates a new map with the specified type and initial space
 // for approximately n elements.
 func MakeMapWithSize(typ Type, n int) Value {
@@ -2118,7 +2128,6 @@ func MakeMapWithSize(typ Type, n int) Value {
 	const (
 		hashmapAlgorithmBinary uint8 = iota
 		hashmapAlgorithmString
-		hashmapAlgorithmInterface
 	)
 
 	if typ.Kind() != Map {
@@ -2132,18 +2141,19 @@ func MakeMapWithSize(typ Type, n int) Value {
 	key := typ.Key().(*RawType)
 	val := typ.Elem().(*RawType)
 
-	var alg uint8
+	var m unsafe.Pointer
 
 	if key.Kind() == String {
-		alg = hashmapAlgorithmString
+		m = hashmapMake(key.Size(), val.Size(), uintptr(n), hashmapAlgorithmString)
 	} else if key.isBinary() {
-		alg = hashmapAlgorithmBinary
+		m = hashmapMake(key.Size(), val.Size(), uintptr(n), hashmapAlgorithmBinary)
 	} else {
-		alg = hashmapAlgorithmInterface
+		// Composite key type (struct with strings, floats, etc.).
+		// Use runtime-generated hash/equal closures that walk the
+		// type structure, matching the compiler-generated functions.
+		m = hashmapMakeReflect(key.Size(), val.Size(), uintptr(n), unsafe.Pointer(key))
 	}
 
-	m := hashmapMake(key.Size(), val.Size(), uintptr(n), alg)
-
 	return Value{
 		typecode: typ.(*RawType),
 		value:    m,

src/internal/syscall/unix/getrandom.go

@@ -1,5 +1,9 @@
+//go:build !tinygo.wasm
+
 package unix
 
+import "syscall"
+
 type GetRandomFlag uintptr
 
 const (
@@ -8,5 +12,7 @@ const (
 )
 
 func GetRandom(p []byte, flags GetRandomFlag) (n int, err error) {
-	panic("todo: unix.GetRandom")
+	// Not supported on most TinyGo targets.
+	// On real Linux the sysrand package will fall back to /dev/urandom.
+	return 0, syscall.ENOSYS
 }