rp2040: fix max SPI frequency

I think the previous numbers came from an older revision of the
datasheet? They're certainly not in the current revision, which gives
62.5MHz as the maximum speed.

.dockerignore

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

.github/workflows/build-macos.yml

@@ -29,11 +29,11 @@ jobs:
         with:
           go-version: '1.20'
           cache: true
-      - name: Cache LLVM source
-        uses: actions/cache@v3
+      - name: Restore LLVM source cache
+        uses: actions/cache/restore@v3
         id: cache-llvm-source
         with:
-          key: llvm-source-15-macos-v2
+          key: llvm-source-15-macos-v3
           path: |
             llvm-project/clang/lib/Headers
             llvm-project/clang/include
@@ -43,11 +43,22 @@ jobs:
       - name: Download LLVM source
         if: steps.cache-llvm-source.outputs.cache-hit != 'true'
         run: make llvm-source
-      - name: Cache LLVM build
-        uses: actions/cache@v3
+      - name: Save LLVM source cache
+        uses: actions/cache/save@v3
+        if: steps.cache-llvm-source.outputs.cache-hit != 'true'
+        with:
+          key: ${{ steps.cache-llvm-source.outputs.cache-primary-key }}
+          path: |
+            llvm-project/clang/lib/Headers
+            llvm-project/clang/include
+            llvm-project/compiler-rt
+            llvm-project/lld/include
+            llvm-project/llvm/include
+      - name: Restore LLVM build cache
+        uses: actions/cache/restore@v3
         id: cache-llvm-build
         with:
-          key: llvm-build-15-macos-v3
+          key: llvm-build-15-macos-v4
           path: llvm-build
       - name: Build LLVM
         if: steps.cache-llvm-build.outputs.cache-hit != 'true'
@@ -61,6 +72,12 @@ jobs:
           # build!
           make llvm-build
           find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
+      - name: Save LLVM build cache
+        uses: actions/cache/save@v3
+        if: steps.cache-llvm-build.outputs.cache-hit != 'true'
+        with:
+          key: ${{ steps.cache-llvm-build.outputs.cache-primary-key }}
+          path: llvm-build
       - name: Cache wasi-libc sysroot
         uses: actions/cache@v3
         id: cache-wasi-libc
@@ -70,9 +87,11 @@ jobs:
       - name: Build wasi-libc
         if: steps.cache-wasi-libc.outputs.cache-hit != 'true'
         run: make wasi-libc
+      - name: make gen-device
+        run: make -j3 gen-device
       - name: Test TinyGo
         shell: bash
-        run: make test GOTESTFLAGS="-v -short"
+        run: make test GOTESTFLAGS="-short"
       - name: Build TinyGo release tarball
         run: make release -j3
       - name: Test stdlib packages

.github/workflows/docker.yml

@@ -31,7 +31,7 @@ jobs:
         with:
           images: |
             tinygo/tinygo-dev
-            ghcr.io/${{ github.repository }}/tinygo-dev
+            ghcr.io/${{ github.repository_owner }}/tinygo-dev
           tags: |
             type=sha,format=long
             type=raw,value=latest
@@ -53,6 +53,7 @@ jobs:
           push: true
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}
+          build-contexts: tinygo-llvm-build=docker-image://tinygo/llvm-15
           cache-from: type=gha
           cache-to: type=gha,mode=max
       - name: Trigger Drivers repo build on Github Actions
@@ -69,21 +70,31 @@ jobs:
           -H "Accept: application/vnd.github.v3+json" \
           https://api.github.com/repos/tinygo-org/bluetooth/actions/workflows/linux.yml/dispatches \
           -d '{"ref": "dev"}'
-      - name: Trigger TinyFS repo build on CircleCI
+      - name: Trigger TinyFS repo build on Github Actions
         run: |
-          curl --location --request POST 'https://circleci.com/api/v2/project/github/tinygo-org/tinyfs/pipeline' \
-            --header 'Content-Type: application/json' \
-            -d '{"branch": "dev"}' \
-            -u "${{ secrets.CIRCLECI_API_TOKEN }}"
-      - name: Trigger TinyFont repo build on CircleCI
+          curl -X POST \
+          -H "Authorization: Bearer ${{secrets.GHA_ACCESS_TOKEN}}" \
+          -H "Accept: application/vnd.github.v3+json" \
+          https://api.github.com/repos/tinygo-org/tinyfs/actions/workflows/build.yml/dispatches \
+          -d '{"ref": "dev"}'
+      - name: Trigger TinyFont repo build on Github Actions
         run: |
-          curl --location --request POST 'https://circleci.com/api/v2/project/github/tinygo-org/tinyfont/pipeline' \
-            --header 'Content-Type: application/json' \
-            -d '{"branch": "dev"}' \
-            -u "${{ secrets.CIRCLECI_API_TOKEN }}"
-      - name: Trigger TinyDraw repo build on CircleCI
+          curl -X POST \
+          -H "Authorization: Bearer ${{secrets.GHA_ACCESS_TOKEN}}" \
+          -H "Accept: application/vnd.github.v3+json" \
+          https://api.github.com/repos/tinygo-org/tinyfont/actions/workflows/build.yml/dispatches \
+          -d '{"ref": "dev"}'
+      - name: Trigger TinyDraw repo build on Github Actions
         run: |
-          curl --location --request POST 'https://circleci.com/api/v2/project/github/tinygo-org/tinydraw/pipeline' \
-            --header 'Content-Type: application/json' \
-            -d '{"branch": "dev"}' \
-            -u "${{ secrets.CIRCLECI_API_TOKEN }}"
+          curl -X POST \
+          -H "Authorization: Bearer ${{secrets.GHA_ACCESS_TOKEN}}" \
+          -H "Accept: application/vnd.github.v3+json" \
+          https://api.github.com/repos/tinygo-org/tinydraw/actions/workflows/build.yml/dispatches \
+          -d '{"ref": "dev"}'
+      - name: Trigger TinyTerm repo build on Github Actions
+        run: |
+          curl -X POST \
+          -H "Authorization: Bearer ${{secrets.GHA_ACCESS_TOKEN}}" \
+          -H "Accept: application/vnd.github.v3+json" \
+          https://api.github.com/repos/tinygo-org/tinyterm/actions/workflows/build.yml/dispatches \
+          -d '{"ref": "dev"}'

.github/workflows/linux.yml

@@ -39,11 +39,11 @@ jobs:
           path: |
             ~/.cache/go-build
             ~/go/pkg/mod
-      - name: Cache LLVM source
-        uses: actions/cache@v3
+      - name: Restore LLVM source cache
+        uses: actions/cache/restore@v3
         id: cache-llvm-source
         with:
-          key: llvm-source-15-linux-alpine-v2
+          key: llvm-source-15-linux-alpine-v3
           path: |
             llvm-project/clang/lib/Headers
             llvm-project/clang/include
@@ -53,11 +53,22 @@ jobs:
       - name: Download LLVM source
         if: steps.cache-llvm-source.outputs.cache-hit != 'true'
         run: make llvm-source
-      - name: Cache LLVM build
-        uses: actions/cache@v3
+      - name: Save LLVM source cache
+        uses: actions/cache/save@v3
+        if: steps.cache-llvm-source.outputs.cache-hit != 'true'
+        with:
+          key: ${{ steps.cache-llvm-source.outputs.cache-primary-key }}
+          path: |
+            llvm-project/clang/lib/Headers
+            llvm-project/clang/include
+            llvm-project/compiler-rt
+            llvm-project/lld/include
+            llvm-project/llvm/include
+      - name: Restore LLVM build cache
+        uses: actions/cache/restore@v3
         id: cache-llvm-build
         with:
-          key: llvm-build-15-linux-alpine-v3
+          key: llvm-build-15-linux-alpine-v4
           path: llvm-build
       - name: Build LLVM
         if: steps.cache-llvm-build.outputs.cache-hit != 'true'
@@ -71,6 +82,12 @@ jobs:
           make llvm-build
           # 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@v3
+        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@v3
         id: cache-binaryen
@@ -122,7 +139,9 @@ jobs:
           cache: true
       - name: Install wasmtime
         run: |
-          curl https://wasmtime.dev/install.sh -sSf | bash
+          mkdir -p $HOME/.wasmtime $HOME/.wasmtime/bin
+          curl https://github.com/bytecodealliance/wasmtime/releases/download/v5.0.0/wasmtime-v5.0.0-x86_64-linux.tar.xz -o wasmtime-v5.0.0-x86_64-linux.tar.xz -SfL
+          tar -C $HOME/.wasmtime/bin --wildcards -xf wasmtime-v5.0.0-x86_64-linux.tar.xz --strip-components=1 wasmtime-v5.0.0-x86_64-linux/*
           echo "$HOME/.wasmtime/bin" >> $GITHUB_PATH
       - name: Download release artifact
         uses: actions/download-artifact@v3
@@ -166,13 +185,15 @@ jobs:
           node-version: '14'
       - name: Install wasmtime
         run: |
-          curl https://wasmtime.dev/install.sh -sSf | bash
+          mkdir -p $HOME/.wasmtime $HOME/.wasmtime/bin
+          curl -L https://github.com/bytecodealliance/wasmtime/releases/download/v5.0.0/wasmtime-v5.0.0-x86_64-linux.tar.xz -o wasmtime-v5.0.0-x86_64-linux.tar.xz -SfL
+          tar -C $HOME/.wasmtime/bin --wildcards -xf wasmtime-v5.0.0-x86_64-linux.tar.xz --strip-components=1 wasmtime-v5.0.0-x86_64-linux/*
           echo "$HOME/.wasmtime/bin" >> $GITHUB_PATH
-      - name: Cache LLVM source
-        uses: actions/cache@v3
+      - name: Restore LLVM source cache
+        uses: actions/cache/restore@v3
         id: cache-llvm-source
         with:
-          key: llvm-source-15-linux-asserts-v2
+          key: llvm-source-15-linux-asserts-v3
           path: |
             llvm-project/clang/lib/Headers
             llvm-project/clang/include
@@ -182,11 +203,22 @@ jobs:
       - name: Download LLVM source
         if: steps.cache-llvm-source.outputs.cache-hit != 'true'
         run: make llvm-source
-      - name: Cache LLVM build
-        uses: actions/cache@v3
+      - name: Save LLVM source cache
+        uses: actions/cache/save@v3
+        if: steps.cache-llvm-source.outputs.cache-hit != 'true'
+        with:
+          key: ${{ steps.cache-llvm-source.outputs.cache-primary-key }}
+          path: |
+            llvm-project/clang/lib/Headers
+            llvm-project/clang/include
+            llvm-project/compiler-rt
+            llvm-project/lld/include
+            llvm-project/llvm/include
+      - name: Restore LLVM build cache
+        uses: actions/cache/restore@v3
         id: cache-llvm-build
         with:
-          key: llvm-build-15-linux-asserts-v3
+          key: llvm-build-15-linux-asserts-v4
           path: llvm-build
       - name: Build LLVM
         if: steps.cache-llvm-build.outputs.cache-hit != 'true'
@@ -198,6 +230,12 @@ jobs:
           make llvm-build ASSERT=1
           # 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@v3
+        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@v3
         id: cache-binaryen
@@ -237,7 +275,7 @@ jobs:
     # in that process to avoid doing lots of duplicate work and to avoid
     # complications around precompiled libraries such as compiler-rt shipped as
     # part of the release tarball.
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-20.04
     needs: build-linux
     steps:
       - name: Checkout
@@ -254,11 +292,11 @@ jobs:
         with:
           go-version: '1.20'
           cache: true
-      - name: Cache LLVM source
-        uses: actions/cache@v3
+      - name: Restore LLVM source cache
+        uses: actions/cache/restore@v3
         id: cache-llvm-source
         with:
-          key: llvm-source-15-linux-v2
+          key: llvm-source-15-linux-v3
           path: |
             llvm-project/clang/lib/Headers
             llvm-project/clang/include
@@ -268,11 +306,22 @@ jobs:
       - name: Download LLVM source
         if: steps.cache-llvm-source.outputs.cache-hit != 'true'
         run: make llvm-source
-      - name: Cache LLVM build
-        uses: actions/cache@v3
+      - name: Save LLVM source cache
+        uses: actions/cache/save@v3
+        if: steps.cache-llvm-source.outputs.cache-hit != 'true'
+        with:
+          key: ${{ steps.cache-llvm-source.outputs.cache-primary-key }}
+          path: |
+            llvm-project/clang/lib/Headers
+            llvm-project/clang/include
+            llvm-project/compiler-rt
+            llvm-project/lld/include
+            llvm-project/llvm/include
+      - name: Restore LLVM build cache
+        uses: actions/cache/restore@v3
         id: cache-llvm-build
         with:
-          key: llvm-build-15-linux-arm-v3
+          key: llvm-build-15-linux-arm-v4
           path: llvm-build
       - name: Build LLVM
         if: steps.cache-llvm-build.outputs.cache-hit != 'true'
@@ -286,6 +335,12 @@ jobs:
           make llvm-build CROSS=arm-linux-gnueabihf
           # Remove unnecessary object files (to reduce cache size).
           find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
+      - name: Save LLVM build cache
+        uses: actions/cache/save@v3
+        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@v3
         id: cache-binaryen
@@ -336,7 +391,7 @@ jobs:
     # in that process to avoid doing lots of duplicate work and to avoid
     # complications around precompiled libraries such as compiler-rt shipped as
     # part of the release tarball.
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-20.04
     needs: build-linux
     steps:
       - name: Checkout
@@ -354,11 +409,11 @@ jobs:
         with:
           go-version: '1.20'
           cache: true
-      - name: Cache LLVM source
-        uses: actions/cache@v3
+      - name: Restore LLVM source cache
+        uses: actions/cache/restore@v3
         id: cache-llvm-source
         with:
-          key: llvm-source-15-linux-v2
+          key: llvm-source-15-linux-v3
           path: |
             llvm-project/clang/lib/Headers
             llvm-project/clang/include
@@ -368,11 +423,22 @@ jobs:
       - name: Download LLVM source
         if: steps.cache-llvm-source.outputs.cache-hit != 'true'
         run: make llvm-source
-      - name: Cache LLVM build
-        uses: actions/cache@v3
+      - name: Save LLVM source cache
+        uses: actions/cache/save@v3
+        if: steps.cache-llvm-source.outputs.cache-hit != 'true'
+        with:
+          key: ${{ steps.cache-llvm-source.outputs.cache-primary-key }}
+          path: |
+            llvm-project/clang/lib/Headers
+            llvm-project/clang/include
+            llvm-project/compiler-rt
+            llvm-project/lld/include
+            llvm-project/llvm/include
+      - name: Restore LLVM build cache
+        uses: actions/cache/restore@v3
         id: cache-llvm-build
         with:
-          key: llvm-build-15-linux-arm64-v3
+          key: llvm-build-15-linux-arm64-v4
           path: llvm-build
       - name: Build LLVM
         if: steps.cache-llvm-build.outputs.cache-hit != 'true'
@@ -384,6 +450,12 @@ jobs:
           make llvm-build CROSS=aarch64-linux-gnu
           # Remove unnecessary object files (to reduce cache size).
           find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
+      - name: Save LLVM build cache
+        uses: actions/cache/save@v3
+        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@v3
         id: cache-binaryen

.github/workflows/llvm.yml

@@ -0,0 +1,63 @@
+# This is the Github action to build and push the LLVM Docker image
+# used by the tinygo/tinygo-dev Docker image.
+#
+# It only needs to be rebuilt when updating the LLVM version.
+#
+# To update, make any needed changes to this file,
+# then push to the "build-llvm-image" branch.
+#
+# The needed image will be rebuilt, which will very likely take at least 1-2 hours.
+name: LLVM
+on:
+  push:
+    branches: [ build-llvm-image ]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build-push-llvm:
+    name: build-push-llvm
+    runs-on: ubuntu-latest
+    permissions:
+      packages: write
+      contents: read
+    steps:
+      - name: Check out the repo
+        uses: actions/checkout@v3
+        with:
+          submodules: recursive
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+      - name: Docker meta
+        id: meta
+        uses: docker/metadata-action@v4
+        with:
+          images: |
+            tinygo/llvm-15
+            ghcr.io/${{ github.repository_owner }}/llvm-15
+          tags: |
+            type=sha,format=long
+            type=raw,value=latest
+      - name: Log in to Docker Hub
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKER_HUB_USERNAME }}
+          password: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}
+      - name: Log in to Github Container Registry
+        uses: docker/login-action@v2
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Build and push
+        uses: docker/build-push-action@v4
+        with:
+          target: tinygo-llvm-build
+          context: .
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max

.github/workflows/windows.yml

@@ -15,6 +15,12 @@ jobs:
   build-windows:
     runs-on: windows-2022
     steps:
+      - name: Configure pagefile
+        uses: al-cheb/configure-pagefile-action@v1.3
+        with:
+          minimum-size: 8GB
+          maximum-size: 24GB
+          disk-root: "C:"
       - uses: brechtm/setup-scoop@v2
         with:
           scoop_update: 'false'
@@ -31,11 +37,11 @@ jobs:
         with:
           go-version: '1.20'
           cache: true
-      - name: Cache LLVM source
-        uses: actions/cache@v3
+      - name: Restore cached LLVM source
+        uses: actions/cache/restore@v3
         id: cache-llvm-source
         with:
-          key: llvm-source-15-windows-v2
+          key: llvm-source-15-windows-v4
           path: |
             llvm-project/clang/lib/Headers
             llvm-project/clang/include
@@ -45,11 +51,22 @@ jobs:
       - name: Download LLVM source
         if: steps.cache-llvm-source.outputs.cache-hit != 'true'
         run: make llvm-source
-      - name: Cache LLVM build
-        uses: actions/cache@v3
+      - name: Save cached LLVM source
+        uses: actions/cache/save@v3
+        if: steps.cache-llvm-source.outputs.cache-hit != 'true'
+        with:
+          key: ${{ steps.cache-llvm-source.outputs.cache-primary-key }}
+          path: |
+            llvm-project/clang/lib/Headers
+            llvm-project/clang/include
+            llvm-project/compiler-rt
+            llvm-project/lld/include
+            llvm-project/llvm/include
+      - name: Restore cached LLVM build
+        uses: actions/cache/restore@v3
         id: cache-llvm-build
         with:
-          key: llvm-build-15-windows-v3
+          key: llvm-build-15-windows-v6
           path: llvm-build
       - name: Build LLVM
         if: steps.cache-llvm-build.outputs.cache-hit != 'true'
@@ -62,6 +79,12 @@ jobs:
           make llvm-build CCACHE=OFF
           # 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@v3
+        if: steps.cache-llvm-build.outputs.cache-hit != 'true'
+        with:
+          key: ${{ steps.cache-llvm-build.outputs.cache-primary-key }}
+          path: llvm-build
       - name: Cache wasi-libc sysroot
         uses: actions/cache@v3
         id: cache-wasi-libc
@@ -74,9 +97,11 @@ jobs:
       - name: Install wasmtime
         run: |
           scoop install wasmtime
+      - name: make gen-device
+        run: make -j3 gen-device
       - name: Test TinyGo
         shell: bash
-        run: make test GOTESTFLAGS="-v -short"
+        run: make test GOTESTFLAGS="-short"
       - name: Build TinyGo release tarball
         shell: bash
         run: make build/release -j4
@@ -100,6 +125,12 @@ jobs:
     runs-on: windows-2022
     needs: build-windows
     steps:
+      - name: Configure pagefile
+        uses: al-cheb/configure-pagefile-action@v1.3
+        with:
+          minimum-size: 8GB
+          maximum-size: 24GB
+          disk-root: "C:"
       - uses: brechtm/setup-scoop@v2
         with:
           scoop_update: 'false'
@@ -131,6 +162,12 @@ jobs:
     runs-on: windows-2022
     needs: build-windows
     steps:
+      - name: Configure pagefile
+        uses: al-cheb/configure-pagefile-action@v1.3
+        with:
+          minimum-size: 8GB
+          maximum-size: 24GB
+          disk-root: "C:"
       - name: Checkout
         uses: actions/checkout@v3
       - name: Install Go
@@ -154,6 +191,12 @@ jobs:
     runs-on: windows-2022
     needs: build-windows
     steps:
+      - name: Configure pagefile
+        uses: al-cheb/configure-pagefile-action@v1.3
+        with:
+          minimum-size: 8GB
+          maximum-size: 24GB
+          disk-root: "C:"
       - uses: brechtm/setup-scoop@v2
         with:
           scoop_update: 'false'

CHANGELOG.md

@@ -416,7 +416,7 @@
   - `interp`: always run atomic and volatile loads/stores at runtime
   - `interp`: bump timeout to 180 seconds
   - `interp`: handle type assertions on nil interfaces
-  - `loader`: elminate goroot cache inconsistency
+  - `loader`: eliminate goroot cache inconsistency
   - `loader`: respect $GOROOT when running `go list`
   - `transform`: allocate the correct amount of bytes in an alloca
   - `transform`: remove switched func lowering
@@ -1115,7 +1115,7 @@
   - `sync`: add WaitGroup
 * **targets**
   - `arm`: allow nesting in DisableInterrupts and EnableInterrupts
-  - `arm`: make FPU configuraton consistent
+  - `arm`: make FPU configuration consistent
   - `arm`: do not mask fault handlers in critical sections
   - `atmega2560`: fix pin mapping for pins D2, D5 and the L port
   - `atsamd`: return an error when an incorrect PWM pin is used
@@ -1144,7 +1144,7 @@
   - `nrf`: add microbit-s110v8 target
   - `nrf`: fix bug in SPI.Tx
   - `nrf`: support debugging the PCA10056
-  - `pygamer`: add Adafruit PyGamer suport
+  - `pygamer`: add Adafruit PyGamer support
   - `riscv`: fix interrupt configuration bug
   - `riscv`: disable linker relaxations during gp init
   - `stm32f4disco`: add new target with ST-Link v2.1 debugger

Makefile

@@ -30,7 +30,7 @@ GO ?= go
 export GOROOT = $(shell $(GO) env GOROOT)
 
 # Flags to pass to go test.
-GOTESTFLAGS ?= -v
+GOTESTFLAGS ?=
 
 # md5sum binary
 MD5SUM = md5sum
@@ -120,10 +120,8 @@ ifeq ($(OS),Windows_NT)
     START_GROUP = -Wl,--start-group
     END_GROUP = -Wl,--end-group
 
-    # LLVM compiled using MinGW on Windows appears to have problems with threads.
-    # Without this flag, linking results in errors like these:
-    #     libLLVMSupport.a(Threading.cpp.obj):Threading.cpp:(.text+0x55): undefined reference to `std::thread::hardware_concurrency()'
-    LLVM_OPTION += -DLLVM_ENABLE_THREADS=OFF -DLLVM_ENABLE_PIC=OFF
+    # PIC needs to be disabled for libclang to work.
+    LLVM_OPTION += -DLLVM_ENABLE_PIC=OFF
 
     CGO_CPPFLAGS += -DCINDEX_NO_EXPORTS
     CGO_LDFLAGS += -static -static-libgcc -static-libstdc++
@@ -281,6 +279,7 @@ TEST_PACKAGES_SLOW = \
 
 # Standard library packages that pass tests quickly on darwin, linux, wasi, and windows
 TEST_PACKAGES_FAST = \
+	compress/lzw \
 	compress/zlib \
 	container/heap \
 	container/list \
@@ -296,6 +295,7 @@ TEST_PACKAGES_FAST = \
 	encoding \
 	encoding/ascii85 \
 	encoding/base32 \
+	encoding/base64 \
 	encoding/csv \
 	encoding/hex \
 	go/scanner \
@@ -308,7 +308,6 @@ TEST_PACKAGES_FAST = \
 	internal/profile \
 	math \
 	math/cmplx \
-	net \
 	net/http/internal/ascii \
 	net/mail \
 	os \
@@ -331,33 +330,39 @@ TEST_PACKAGES_FAST += crypto/elliptic/internal/fiat
 endif
 
 # archive/zip requires os.ReadAt, which is not yet supported on windows
+# bytes requires mmap
 # compress/flate appears to hang on wasi
-# compress/lzw appears to hang on wasi
 # crypto/hmac fails on wasi, it exits with a "slice out of range" panic
 # debug/plan9obj requires os.ReadAt, which is not yet supported on windows
+# 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/quotedprintable requires syscall.Faccessat
 # strconv requires recover() which is not yet supported on wasi
+# text/tabwriter requries recover(), which is not  yet supported on wasi
 # text/template/parse requires recover(), which is not yet supported on wasi
 # testing/fstest requires os.ReadDir, which is not yet supported on windows or wasi
 
 # Additional standard library packages that pass tests on individual platforms
 TEST_PACKAGES_LINUX := \
 	archive/zip \
+	bytes \
 	compress/flate \
-	compress/lzw \
 	crypto/hmac \
 	debug/dwarf \
 	debug/plan9obj \
+	image \
 	io/ioutil \
+	mime/quotedprintable \
+	net \
 	strconv \
 	testing/fstest \
+	text/tabwriter \
 	text/template/parse
 
 TEST_PACKAGES_DARWIN := $(TEST_PACKAGES_LINUX)
 
 TEST_PACKAGES_WINDOWS := \
 	compress/flate \
-	compress/lzw \
 	crypto/hmac \
 	strconv \
 	text/template/parse \
@@ -465,6 +470,8 @@ smoketest:
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/pininterrupt
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=nano-rp2040         examples/rtcinterrupt
+	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/serial
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=pca10040            examples/systick
@@ -629,6 +636,8 @@ endif
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=trinkey-qt2040      examples/temp
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=gopher-badge      examples/blinky1
+	@$(MD5SUM) test.hex
 	# test pwm
 	$(TINYGO) build -size short -o test.hex -target=itsybitsy-m0        examples/pwm
 	@$(MD5SUM) test.hex

builder/build.go

@@ -169,6 +169,7 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 		CodeModel:       config.CodeModel(),
 		RelocationModel: config.RelocationModel(),
 		SizeLevel:       sizeLevel,
+		TinyGoVersion:   goenv.Version,
 
 		Scheduler:          config.Scheduler(),
 		AutomaticStackSize: config.AutomaticStackSize(),
@@ -190,6 +191,9 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 	lprogram, err := loader.Load(config, pkgName, config.ClangHeaders, types.Config{
 		Sizes: compiler.Sizes(machine),
 	})
+	if err != nil {
+		return BuildResult{}, err
+	}
 	result := BuildResult{
 		ModuleRoot: lprogram.MainPkg().Module.Dir,
 		MainDir:    lprogram.MainPkg().Dir,
@@ -199,9 +203,6 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 		// If there is no module root, just the regular root.
 		result.ModuleRoot = lprogram.MainPkg().Root
 	}
-	if err != nil { // failed to load AST
-		return result, err
-	}
 	err = lprogram.Parse()
 	if err != nil {
 		return result, err
@@ -305,7 +306,6 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 				actionID := packageAction{
 					ImportPath:       pkg.ImportPath,
 					CompilerBuildID:  string(compilerBuildID),
-					TinyGoVersion:    goenv.Version,
 					LLVMVersion:      llvm.Version,
 					Config:           compilerConfig,
 					CFlags:           pkg.CFlags,
@@ -594,12 +594,7 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 			defer llvmBuf.Dispose()
 			return result, os.WriteFile(outpath, llvmBuf.Bytes(), 0666)
 		case ".bc":
-			var buf llvm.MemoryBuffer
-			if config.UseThinLTO() {
-				buf = llvm.WriteThinLTOBitcodeToMemoryBuffer(mod)
-			} else {
-				buf = llvm.WriteBitcodeToMemoryBuffer(mod)
-			}
+			buf := llvm.WriteThinLTOBitcodeToMemoryBuffer(mod)
 			defer buf.Dispose()
 			return result, os.WriteFile(outpath, buf.Bytes(), 0666)
 		case ".ll":
@@ -621,16 +616,7 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 		dependencies: []*compileJob{programJob},
 		result:       objfile,
 		run: func(*compileJob) error {
-			var llvmBuf llvm.MemoryBuffer
-			if config.UseThinLTO() {
-				llvmBuf = llvm.WriteThinLTOBitcodeToMemoryBuffer(mod)
-			} else {
-				var err error
-				llvmBuf, err = machine.EmitToMemoryBuffer(mod, llvm.ObjectFile)
-				if err != nil {
-					return err
-				}
-			}
+			llvmBuf := llvm.WriteThinLTOBitcodeToMemoryBuffer(mod)
 			defer llvmBuf.Dispose()
 			return os.WriteFile(objfile, llvmBuf.Bytes(), 0666)
 		},
@@ -664,7 +650,7 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 		job := &compileJob{
 			description: "compile extra file " + path,
 			run: func(job *compileJob) error {
-				result, err := compileAndCacheCFile(abspath, tmpdir, config.CFlags(), config.UseThinLTO(), config.Options.PrintCommands)
+				result, err := compileAndCacheCFile(abspath, tmpdir, config.CFlags(), config.Options.PrintCommands)
 				job.result = result
 				return err
 			},
@@ -682,7 +668,7 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 			job := &compileJob{
 				description: "compile CGo file " + abspath,
 				run: func(job *compileJob) error {
-					result, err := compileAndCacheCFile(abspath, tmpdir, pkg.CFlags, config.UseThinLTO(), config.Options.PrintCommands)
+					result, err := compileAndCacheCFile(abspath, tmpdir, pkg.CFlags, config.Options.PrintCommands)
 					job.result = result
 					return err
 				},
@@ -741,36 +727,34 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 				}
 				ldflags = append(ldflags, dependency.result)
 			}
-			if config.UseThinLTO() {
-				ldflags = append(ldflags, "-mllvm", "-mcpu="+config.CPU())
-				if config.GOOS() == "windows" {
-					// Options for the MinGW wrapper for the lld COFF linker.
-					ldflags = append(ldflags,
-						"-Xlink=/opt:lldlto="+strconv.Itoa(optLevel),
-						"--thinlto-cache-dir="+filepath.Join(cacheDir, "thinlto"))
-				} else if config.GOOS() == "darwin" {
-					// Options for the ld64-compatible lld linker.
-					ldflags = append(ldflags,
-						"--lto-O"+strconv.Itoa(optLevel),
-						"-cache_path_lto", filepath.Join(cacheDir, "thinlto"))
-				} else {
-					// Options for the ELF linker.
-					ldflags = append(ldflags,
-						"--lto-O"+strconv.Itoa(optLevel),
-						"--thinlto-cache-dir="+filepath.Join(cacheDir, "thinlto"),
-					)
-				}
-				if config.CodeModel() != "default" {
-					ldflags = append(ldflags,
-						"-mllvm", "-code-model="+config.CodeModel())
-				}
-				if sizeLevel >= 2 {
-					// Workaround with roughly the same effect as
-					// https://reviews.llvm.org/D119342.
-					// Can hopefully be removed in LLVM 15.
-					ldflags = append(ldflags,
-						"-mllvm", "--rotation-max-header-size=0")
-				}
+			ldflags = append(ldflags, "-mllvm", "-mcpu="+config.CPU())
+			if config.GOOS() == "windows" {
+				// Options for the MinGW wrapper for the lld COFF linker.
+				ldflags = append(ldflags,
+					"-Xlink=/opt:lldlto="+strconv.Itoa(optLevel),
+					"--thinlto-cache-dir="+filepath.Join(cacheDir, "thinlto"))
+			} else if config.GOOS() == "darwin" {
+				// Options for the ld64-compatible lld linker.
+				ldflags = append(ldflags,
+					"--lto-O"+strconv.Itoa(optLevel),
+					"-cache_path_lto", filepath.Join(cacheDir, "thinlto"))
+			} else {
+				// Options for the ELF linker.
+				ldflags = append(ldflags,
+					"--lto-O"+strconv.Itoa(optLevel),
+					"--thinlto-cache-dir="+filepath.Join(cacheDir, "thinlto"),
+				)
+			}
+			if config.CodeModel() != "default" {
+				ldflags = append(ldflags,
+					"-mllvm", "-code-model="+config.CodeModel())
+			}
+			if sizeLevel >= 2 {
+				// Workaround with roughly the same effect as
+				// https://reviews.llvm.org/D119342.
+				// Can hopefully be removed in LLVM 15.
+				ldflags = append(ldflags,
+					"-mllvm", "--rotation-max-header-size=0")
 			}
 			if config.Options.PrintCommands != nil {
 				config.Options.PrintCommands(config.Target.Linker, ldflags...)
@@ -1069,10 +1053,6 @@ func optimizeProgram(mod llvm.Module, config *compileopts.Config) error {
 		}
 	}
 
-	if config.GOOS() != "darwin" && !config.UseThinLTO() {
-		transform.ApplyFunctionSections(mod) // -ffunction-sections
-	}
-
 	// Insert values from -ldflags="-X ..." into the IR.
 	err = setGlobalValues(mod, config.Options.GlobalValues)
 	if err != nil {

builder/cc.go

@@ -56,7 +56,7 @@ import (
 //     depfile but without invalidating its name. For this reason, the depfile is
 //     written on each new compilation (even when it seems unnecessary). However, it
 //     could in rare cases lead to a stale file fetched from the cache.
-func compileAndCacheCFile(abspath, tmpdir string, cflags []string, thinlto bool, printCommands func(string, ...string)) (string, error) {
+func compileAndCacheCFile(abspath, tmpdir string, cflags []string, printCommands func(string, ...string)) (string, error) {
 	// Hash input file.
 	fileHash, err := hashFile(abspath)
 	if err != nil {
@@ -67,11 +67,6 @@ func compileAndCacheCFile(abspath, tmpdir string, cflags []string, thinlto bool,
 	unlock := lock(filepath.Join(goenv.Get("GOCACHE"), fileHash+".c.lock"))
 	defer unlock()
 
-	ext := ".o"
-	if thinlto {
-		ext = ".bc"
-	}
-
 	// Create cache key for the dependencies file.
 	buf, err := json.Marshal(struct {
 		Path        string
@@ -104,7 +99,7 @@ func compileAndCacheCFile(abspath, tmpdir string, cflags []string, thinlto bool,
 		}
 
 		// Obtain hashes of all the files listed as a dependency.
-		outpath, err := makeCFileCachePath(dependencies, depfileNameHash, ext)
+		outpath, err := makeCFileCachePath(dependencies, depfileNameHash)
 		if err == nil {
 			if _, err := os.Stat(outpath); err == nil {
 				return outpath, nil
@@ -117,7 +112,7 @@ func compileAndCacheCFile(abspath, tmpdir string, cflags []string, thinlto bool,
 		return "", err
 	}
 
-	objTmpFile, err := os.CreateTemp(goenv.Get("GOCACHE"), "tmp-*"+ext)
+	objTmpFile, err := os.CreateTemp(goenv.Get("GOCACHE"), "tmp-*.bc")
 	if err != nil {
 		return "", err
 	}
@@ -127,11 +122,8 @@ func compileAndCacheCFile(abspath, tmpdir string, cflags []string, thinlto bool,
 		return "", err
 	}
 	depTmpFile.Close()
-	flags := append([]string{}, cflags...)                                   // copy cflags
-	flags = append(flags, "-MD", "-MV", "-MTdeps", "-MF", depTmpFile.Name()) // autogenerate dependencies
-	if thinlto {
-		flags = append(flags, "-flto=thin")
-	}
+	flags := append([]string{}, cflags...)                                                 // copy cflags
+	flags = append(flags, "-MD", "-MV", "-MTdeps", "-MF", depTmpFile.Name(), "-flto=thin") // autogenerate dependencies
 	flags = append(flags, "-c", "-o", objTmpFile.Name(), abspath)
 	if strings.ToLower(filepath.Ext(abspath)) == ".s" {
 		// If this is an assembly file (.s or .S, lowercase or uppercase), then
@@ -189,7 +181,7 @@ func compileAndCacheCFile(abspath, tmpdir string, cflags []string, thinlto bool,
 	}
 
 	// Move temporary object file to final location.
-	outpath, err := makeCFileCachePath(dependencySlice, depfileNameHash, ext)
+	outpath, err := makeCFileCachePath(dependencySlice, depfileNameHash)
 	if err != nil {
 		return "", err
 	}
@@ -204,7 +196,7 @@ func compileAndCacheCFile(abspath, tmpdir string, cflags []string, thinlto bool,
 // Create a cache path (a path in GOCACHE) to store the output of a compiler
 // job. This path is based on the dep file name (which is a hash of metadata
 // including compiler flags) and the hash of all input files in the paths slice.
-func makeCFileCachePath(paths []string, depfileNameHash, ext string) (string, error) {
+func makeCFileCachePath(paths []string, depfileNameHash string) (string, error) {
 	// Hash all input files.
 	fileHashes := make(map[string]string, len(paths))
 	for _, path := range paths {
@@ -229,7 +221,7 @@ func makeCFileCachePath(paths []string, depfileNameHash, ext string) (string, er
 	outFileNameBuf := sha512.Sum512_224(buf)
 	cacheKey := hex.EncodeToString(outFileNameBuf[:])
 
-	outpath := filepath.Join(goenv.Get("GOCACHE"), "obj-"+cacheKey+ext)
+	outpath := filepath.Join(goenv.Get("GOCACHE"), "obj-"+cacheKey+".bc")
 	return outpath, nil
 }
 

builder/lld.cpp

@@ -3,25 +3,39 @@
 // This file provides C wrappers for liblld.
 
 #include <lld/Common/Driver.h>
+#include <llvm/Support/Parallel.h>
 
 extern "C" {
 
+static void configure() {
+#if _WIN64
+	// This is a hack to work around a hang in the LLD linker on Windows, with
+	// -DLLVM_ENABLE_THREADS=ON. It has a similar effect as the -threads=1
+	// linker flag, but with support for the COFF linker.
+	llvm::parallel::strategy = llvm::hardware_concurrency(1);
+#endif
+}
+
 bool tinygo_link_elf(int argc, char **argv) {
+	configure();
 	std::vector<const char*> args(argv, argv + argc);
 	return lld::elf::link(args, llvm::outs(), llvm::errs(), false, false);
 }
 
 bool tinygo_link_macho(int argc, char **argv) {
+	configure();
 	std::vector<const char*> args(argv, argv + argc);
 	return lld::macho::link(args, llvm::outs(), llvm::errs(), false, false);
 }
 
 bool tinygo_link_mingw(int argc, char **argv) {
+	configure();
 	std::vector<const char*> args(argv, argv + argc);
 	return lld::mingw::link(args, llvm::outs(), llvm::errs(), false, false);
 }
 
 bool tinygo_link_wasm(int argc, char **argv) {
+	configure();
 	std::vector<const char*> args(argv, argv + argc);
 	return lld::wasm::link(args, llvm::outs(), llvm::errs(), false, false);
 }

builder/sizes.go

@@ -75,6 +75,7 @@ func (ps *packageSize) RAM() uint64 {
 type addressLine struct {
 	Address    uint64
 	Length     uint64 // length of this chunk
+	Align      uint64 // (maximum) alignment of this line
 	File       string // file path as stored in DWARF
 	IsVariable bool   // true if this is a variable (or constant), false if it is code
 }
@@ -86,6 +87,7 @@ type memorySection struct {
 	Type    memoryType
 	Address uint64
 	Size    uint64
+	Align   uint64
 }
 
 type memoryType int
@@ -117,17 +119,13 @@ var (
 	//   alloc:  heap allocations during init interpretation
 	//   pack:   data created when storing a constant in an interface for example
 	//   string: buffer behind strings
-	packageSymbolRegexp = regexp.MustCompile(`\$(alloc|embedfsfiles|embedfsslice|embedslice|pack|string)(\.[0-9]+)?$`)
-
-	// Reflect sidetables. Created by the reflect lowering pass.
-	// See src/reflect/sidetables.go.
-	reflectDataRegexp = regexp.MustCompile(`^reflect\.[a-zA-Z]+Sidetable$`)
+	packageSymbolRegexp = regexp.MustCompile(`\$(alloc|pack|string)(\.[0-9]+)?$`)
 )
 
 // readProgramSizeFromDWARF reads the source location for each line of code and
 // each variable in the program, as far as this is stored in the DWARF debug
 // information.
-func readProgramSizeFromDWARF(data *dwarf.Data, codeOffset uint64, skipTombstone bool) ([]addressLine, error) {
+func readProgramSizeFromDWARF(data *dwarf.Data, codeOffset, codeAlignment uint64, skipTombstone bool) ([]addressLine, error) {
 	r := data.Reader()
 	var lines []*dwarf.LineFile
 	var addresses []addressLine
@@ -199,6 +197,7 @@ func readProgramSizeFromDWARF(data *dwarf.Data, codeOffset uint64, skipTombstone
 					line := addressLine{
 						Address: prevLineEntry.Address + codeOffset,
 						Length:  lineEntry.Address - prevLineEntry.Address,
+						Align:   codeAlignment,
 						File:    prevLineEntry.File.Name,
 					}
 					if line.Length != 0 {
@@ -223,20 +222,9 @@ func readProgramSizeFromDWARF(data *dwarf.Data, codeOffset uint64, skipTombstone
 			// Try to parse the location. While this could in theory be a very
 			// complex expression, usually it's just a DW_OP_addr opcode
 			// followed by an address.
-			locationCode := location.Val.([]uint8)
-			if locationCode[0] != 3 { // DW_OP_addr
-				continue
-			}
-			var addr uint64
-			switch len(locationCode) {
-			case 1 + 2:
-				addr = uint64(binary.LittleEndian.Uint16(locationCode[1:]))
-			case 1 + 4:
-				addr = uint64(binary.LittleEndian.Uint32(locationCode[1:]))
-			case 1 + 8:
-				addr = binary.LittleEndian.Uint64(locationCode[1:])
-			default:
-				continue // unknown address
+			addr, err := readDWARFConstant(r.AddressSize(), location.Val.([]uint8))
+			if err != nil {
+				continue // ignore the error, we don't know what to do with it
 			}
 
 			// Parse the type of the global variable, which (importantly)
@@ -247,9 +235,16 @@ func readProgramSizeFromDWARF(data *dwarf.Data, codeOffset uint64, skipTombstone
 				return nil, err
 			}
 
+			// Read alignment, if it's stored as part of the debug information.
+			var alignment uint64
+			if attr := e.AttrField(dwarf.AttrAlignment); attr != nil {
+				alignment = uint64(attr.Val.(int64))
+			}
+
 			addresses = append(addresses, addressLine{
 				Address:    addr,
 				Length:     uint64(typ.Size()),
+				Align:      alignment,
 				File:       lines[file.Val.(int64)].Name,
 				IsVariable: true,
 			})
@@ -260,6 +255,52 @@ func readProgramSizeFromDWARF(data *dwarf.Data, codeOffset uint64, skipTombstone
 	return addresses, nil
 }
 
+// Parse a DWARF constant. For addresses, this is usually a very simple
+// expression.
+func readDWARFConstant(addressSize int, bytecode []byte) (uint64, error) {
+	var addr uint64
+	for len(bytecode) != 0 {
+		op := bytecode[0]
+		bytecode = bytecode[1:]
+		switch op {
+		case 0x03: // DW_OP_addr
+			switch addressSize {
+			case 2:
+				addr = uint64(binary.LittleEndian.Uint16(bytecode))
+			case 4:
+				addr = uint64(binary.LittleEndian.Uint32(bytecode))
+			case 8:
+				addr = binary.LittleEndian.Uint64(bytecode)
+			default:
+				panic("unexpected address size")
+			}
+			bytecode = bytecode[addressSize:]
+		case 0x23: // DW_OP_plus_uconst
+			offset, n := readULEB128(bytecode)
+			addr += offset
+			bytecode = bytecode[n:]
+		default:
+			return 0, fmt.Errorf("unknown DWARF opcode: 0x%x", op)
+		}
+	}
+	return addr, nil
+}
+
+// Source: https://en.wikipedia.org/wiki/LEB128#Decode_unsigned_integer
+func readULEB128(buf []byte) (result uint64, n int) {
+	var shift uint8
+	for {
+		b := buf[n]
+		n++
+		result |= uint64(b&0x7f) << shift
+		if b&0x80 == 0 {
+			break
+		}
+		shift += 7
+	}
+	return
+}
+
 // Read a MachO object file and return a line table.
 // Also return an index from symbol name to start address in the line table.
 func readMachOSymbolAddresses(path string) (map[string]int, []addressLine, error) {
@@ -281,7 +322,7 @@ func readMachOSymbolAddresses(path string) (map[string]int, []addressLine, error
 	if err != nil {
 		return nil, nil, err
 	}
-	lines, err := readProgramSizeFromDWARF(dwarf, 0, false)
+	lines, err := readProgramSizeFromDWARF(dwarf, 0, 0, false)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -338,10 +379,15 @@ func loadProgramSize(path string, packagePathMap map[string]string) (*programSiz
 	// Load the binary file, which could be in a number of file formats.
 	var sections []memorySection
 	if file, err := elf.NewFile(f); err == nil {
+		var codeAlignment uint64
+		switch file.Machine {
+		case elf.EM_ARM:
+			codeAlignment = 4 // usually 2, but can be 4
+		}
 		// Read DWARF information. The error is intentionally ignored.
 		data, _ := file.DWARF()
 		if data != nil {
-			addresses, err = readProgramSizeFromDWARF(data, 0, true)
+			addresses, err = readProgramSizeFromDWARF(data, 0, codeAlignment, true)
 			if err != nil {
 				// However, _do_ report an error here. Something must have gone
 				// wrong while trying to parse DWARF data.
@@ -375,7 +421,7 @@ func loadProgramSize(path string, packagePathMap map[string]string) (*programSiz
 			if section.Flags&elf.SHF_ALLOC == 0 {
 				continue
 			}
-			if packageSymbolRegexp.MatchString(symbol.Name) || reflectDataRegexp.MatchString(symbol.Name) {
+			if packageSymbolRegexp.MatchString(symbol.Name) || symbol.Name == "__isr_vector" {
 				addresses = append(addresses, addressLine{
 					Address:    symbol.Value,
 					Length:     symbol.Size,
@@ -399,6 +445,7 @@ func loadProgramSize(path string, packagePathMap map[string]string) (*programSiz
 					sections = append(sections, memorySection{
 						Address: section.Addr,
 						Size:    section.Size,
+						Align:   section.Addralign,
 						Type:    memoryStack,
 					})
 				} else {
@@ -406,6 +453,7 @@ func loadProgramSize(path string, packagePathMap map[string]string) (*programSiz
 					sections = append(sections, memorySection{
 						Address: section.Addr,
 						Size:    section.Size,
+						Align:   section.Addralign,
 						Type:    memoryBSS,
 					})
 				}
@@ -414,6 +462,7 @@ func loadProgramSize(path string, packagePathMap map[string]string) (*programSiz
 				sections = append(sections, memorySection{
 					Address: section.Addr,
 					Size:    section.Size,
+					Align:   section.Addralign,
 					Type:    memoryCode,
 				})
 			} else if section.Type == elf.SHT_PROGBITS && section.Flags&elf.SHF_WRITE != 0 {
@@ -421,6 +470,7 @@ func loadProgramSize(path string, packagePathMap map[string]string) (*programSiz
 				sections = append(sections, memorySection{
 					Address: section.Addr,
 					Size:    section.Size,
+					Align:   section.Addralign,
 					Type:    memoryData,
 				})
 			} else if section.Type == elf.SHT_PROGBITS {
@@ -428,6 +478,7 @@ func loadProgramSize(path string, packagePathMap map[string]string) (*programSiz
 				sections = append(sections, memorySection{
 					Address: section.Addr,
 					Size:    section.Size,
+					Align:   section.Addralign,
 					Type:    memoryROData,
 				})
 			}
@@ -454,6 +505,7 @@ func loadProgramSize(path string, packagePathMap map[string]string) (*programSiz
 				sections = append(sections, memorySection{
 					Address: section.Addr,
 					Size:    uint64(section.Size),
+					Align:   uint64(section.Align),
 					Type:    memoryCode,
 				})
 			} else if sectionType == 1 { // S_ZEROFILL
@@ -461,6 +513,7 @@ func loadProgramSize(path string, packagePathMap map[string]string) (*programSiz
 				sections = append(sections, memorySection{
 					Address: section.Addr,
 					Size:    uint64(section.Size),
+					Align:   uint64(section.Align),
 					Type:    memoryBSS,
 				})
 			} else if segment.Maxprot&0b011 == 0b001 { // --r (read-only data)
@@ -468,6 +521,7 @@ func loadProgramSize(path string, packagePathMap map[string]string) (*programSiz
 				sections = append(sections, memorySection{
 					Address: section.Addr,
 					Size:    uint64(section.Size),
+					Align:   uint64(section.Align),
 					Type:    memoryROData,
 				})
 			} else {
@@ -475,6 +529,7 @@ func loadProgramSize(path string, packagePathMap map[string]string) (*programSiz
 				sections = append(sections, memorySection{
 					Address: section.Addr,
 					Size:    uint64(section.Size),
+					Align:   uint64(section.Align),
 					Type:    memoryData,
 				})
 			}
@@ -558,7 +613,7 @@ func loadProgramSize(path string, packagePathMap map[string]string) (*programSiz
 		// Read DWARF information. The error is intentionally ignored.
 		data, _ := file.DWARF()
 		if data != nil {
-			addresses, err = readProgramSizeFromDWARF(data, 0, true)
+			addresses, err = readProgramSizeFromDWARF(data, 0, 0, true)
 			if err != nil {
 				// However, _do_ report an error here. Something must have gone
 				// wrong while trying to parse DWARF data.
@@ -630,7 +685,7 @@ func loadProgramSize(path string, packagePathMap map[string]string) (*programSiz
 		// Read DWARF information. The error is intentionally ignored.
 		data, _ := file.DWARF()
 		if data != nil {
-			addresses, err = readProgramSizeFromDWARF(data, codeOffset, true)
+			addresses, err = readProgramSizeFromDWARF(data, codeOffset, 0, true)
 			if err != nil {
 				// However, _do_ report an error here. Something must have gone
 				// wrong while trying to parse DWARF data.
@@ -790,10 +845,18 @@ func readSection(section memorySection, addresses []addressLine, addSize func(st
 		if addr < line.Address {
 			// There is a gap: there is a space between the current and the
 			// previous line entry.
-			addSize("(unknown)", line.Address-addr, false)
-			if sizesDebug {
-				fmt.Printf("%08x..%08x %5d:  unknown (gap)\n", addr, line.Address, line.Address-addr)
+			// Check whether this is caused by alignment requirements.
+			addrAligned := (addr + line.Align - 1) &^ (line.Align - 1)
+			if line.Align > 1 && addrAligned >= line.Address {
+				// It is, assume that's what causes the gap.
+				addSize("(padding)", line.Address-addr, true)
+			} else {
+				addSize("(unknown)", line.Address-addr, false)
+				if sizesDebug {
+					fmt.Printf("%08x..%08x %5d:  unknown (gap), alignment=%d\n", addr, line.Address, line.Address-addr, line.Align)
+				}
 			}
+			addr = line.Address
 		}
 		if addr > line.Address+line.Length {
 			// The current line is already covered by a previous line entry.
@@ -815,9 +878,16 @@ func readSection(section memorySection, addresses []addressLine, addSize func(st
 	}
 	if addr < sectionEnd {
 		// There is a gap at the end of the section.
-		addSize("(unknown)", sectionEnd-addr, false)
-		if sizesDebug {
-			fmt.Printf("%08x..%08x %5d:  unknown (end)\n", addr, sectionEnd, sectionEnd-addr)
+		addrAligned := (addr + section.Align - 1) &^ (section.Align - 1)
+		if section.Align > 1 && addrAligned >= sectionEnd {
+			// The gap is caused by the section alignment.
+			// For example, if a .rodata section ends with a non-aligned string.
+			addSize("(padding)", sectionEnd-addr, true)
+		} else {
+			addSize("(unknown)", sectionEnd-addr, false)
+			if sizesDebug {
+				fmt.Printf("%08x..%08x %5d:  unknown (end), alignment=%d\n", addr, sectionEnd, sectionEnd-addr, section.Align)
+			}
 		}
 	}
 }
@@ -833,12 +903,15 @@ func findPackagePath(path string, packagePathMap map[string]string) string {
 			// package, with a "C" prefix. For example: "C compiler-rt" for the
 			// compiler runtime library from LLVM.
 			packagePath = "C " + strings.Split(strings.TrimPrefix(path, filepath.Join(goenv.Get("TINYGOROOT"), "lib")), string(os.PathSeparator))[1]
+		} else if strings.HasPrefix(path, filepath.Join(goenv.Get("TINYGOROOT"), "llvm-project")) {
+			packagePath = "C compiler-rt"
 		} else if packageSymbolRegexp.MatchString(path) {
 			// Parse symbol names like main$alloc or runtime$string.
 			packagePath = path[:strings.LastIndex(path, "$")]
-		} else if reflectDataRegexp.MatchString(path) {
-			// Parse symbol names like reflect.structTypesSidetable.
-			packagePath = "Go reflect data"
+		} else if path == "__isr_vector" {
+			packagePath = "C interrupt vector"
+		} else if path == "<Go type>" {
+			packagePath = "Go types"
 		} else if path == "<Go interface assert>" {
 			// Interface type assert, generated by the interface lowering pass.
 			packagePath = "Go interface assert"

builder/sizes_test.go

@@ -0,0 +1,92 @@
+package builder
+
+import (
+	"runtime"
+	"testing"
+	"time"
+
+	"github.com/tinygo-org/tinygo/compileopts"
+)
+
+var sema = make(chan struct{}, runtime.NumCPU())
+
+type sizeTest struct {
+	target     string
+	path       string
+	codeSize   uint64
+	rodataSize uint64
+	dataSize   uint64
+	bssSize    uint64
+}
+
+// Test whether code and data size is as expected for the given targets.
+// This tests both the logic of loadProgramSize and checks that code size
+// doesn't change unintentionally.
+//
+// If you find that code or data size is reduced, then great! You can reduce the
+// number in this test.
+// If you find that the code or data size is increased, take a look as to why
+// this is. It could be due to an update (LLVM version, Go version, etc) which
+// is fine, but it could also mean that a recent change introduced this size
+// increase. If so, please consider whether this new feature is indeed worth the
+// size increase for all users.
+func TestBinarySize(t *testing.T) {
+	if runtime.GOOS == "linux" && !hasBuiltinTools {
+		// Debian LLVM packages are modified a bit and tend to produce
+		// different machine code. Ideally we'd fix this (with some attributes
+		// or something?), but for now skip it.
+		t.Skip("Skip: using external LLVM version so binary size might differ")
+	}
+
+	// This is a small number of very diverse targets that we want to test.
+	tests := []sizeTest{
+		// microcontrollers
+		{"hifive1b", "examples/echo", 4556, 272, 0, 2252},
+		{"microbit", "examples/serial", 2680, 380, 8, 2256},
+		{"wioterminal", "examples/pininterrupt", 6109, 1471, 116, 6816},
+
+		// TODO: also check wasm. Right now this is difficult, because
+		// wasm binaries are run through wasm-opt and therefore the
+		// output varies by binaryen version.
+	}
+	for _, tc := range tests {
+		tc := tc
+		t.Run(tc.target+"/"+tc.path, func(t *testing.T) {
+			t.Parallel()
+
+			// Build the binary.
+			options := compileopts.Options{
+				Target:        tc.target,
+				Opt:           "z",
+				Semaphore:     sema,
+				InterpTimeout: 60 * time.Second,
+				Debug:         true,
+				VerifyIR:      true,
+			}
+			target, err := compileopts.LoadTarget(&options)
+			if err != nil {
+				t.Fatal("could not load target:", err)
+			}
+			config := &compileopts.Config{
+				Options: &options,
+				Target:  target,
+			}
+			result, err := Build(tc.path, "", t.TempDir(), config)
+			if err != nil {
+				t.Fatal("could not build:", err)
+			}
+
+			// Check whether the size of the binary matches the expected size.
+			sizes, err := loadProgramSize(result.Executable, nil)
+			if err != nil {
+				t.Fatal("could not read program size:", err)
+			}
+			if sizes.Code != tc.codeSize || sizes.ROData != tc.rodataSize || sizes.Data != tc.dataSize || sizes.BSS != tc.bssSize {
+				t.Errorf("Unexpected code size when compiling: -target=%s %s", tc.target, tc.path)
+				t.Errorf("            code rodata   data    bss")
+				t.Errorf("expected: %6d %6d %6d %6d", tc.codeSize, tc.rodataSize, tc.dataSize, tc.bssSize)
+				t.Errorf("actual:   %6d %6d %6d %6d", sizes.Code, sizes.ROData, sizes.Data, sizes.BSS)
+			}
+		})
+	}
+}

compileopts/config.go

@@ -75,7 +75,8 @@ func (c *Config) GOARM() string {
 
 // BuildTags returns the complete list of build tags used during this build.
 func (c *Config) BuildTags() []string {
-	tags := append(c.Target.BuildTags, []string{"tinygo", "math_big_pure_go", "gc." + c.GC(), "scheduler." + c.Scheduler(), "serial." + c.Serial()}...)
+	targetTags := filterTags(c.Target.BuildTags, c.Options.Tags)
+	tags := append(targetTags, []string{"tinygo", "math_big_pure_go", "gc." + c.GC(), "scheduler." + c.Scheduler(), "serial." + c.Serial()}...)
 	for i := 1; i <= c.GoMinorVersion; i++ {
 		tags = append(tags, fmt.Sprintf("go1.%d", i))
 	}
@@ -190,14 +191,6 @@ func (c *Config) StackSize() uint64 {
 	return c.Target.DefaultStackSize
 }
 
-// UseThinLTO returns whether ThinLTO should be used for the given target.
-func (c *Config) UseThinLTO() bool {
-	// All architectures support ThinLTO now. However, this code is kept for the
-	// time being in case there are regressions. The non-ThinLTO code support
-	// should be removed when it is proven to work reliably.
-	return true
-}
-
 // RP2040BootPatch returns whether the RP2040 boot patch should be applied that
 // calculates and patches in the checksum for the 2nd stage bootloader.
 func (c *Config) RP2040BootPatch() bool {
@@ -548,5 +541,36 @@ func (c *Config) Emulator(format, binary string) ([]string, error) {
 
 type TestConfig struct {
 	CompileTestBinary bool
-	// TODO: Filter the test functions to run, include verbose flag, etc
+	CompileOnly       bool
+	Verbose           bool
+	Short             bool
+	RunRegexp         string
+	Count             *int
+	BenchRegexp       string
+	BenchTime         string
+	BenchMem          bool
+}
+
+// filterTags removes predefined build tags for a target if a conflicting option
+// is provided by the user.
+func filterTags(targetTags []string, userTags []string) []string {
+	var filtered []string
+	for _, t := range targetTags {
+		switch {
+		case strings.HasPrefix(t, "runtime_memhash_"):
+			overridden := false
+			for _, ut := range userTags {
+				if strings.HasPrefix(ut, "runtime_memhash_") {
+					overridden = true
+					break
+				}
+			}
+			if !overridden {
+				filtered = append(filtered, t)
+			}
+		default:
+			filtered = append(filtered, t)
+		}
+	}
+	return filtered
 }

compileopts/config_test.go

@@ -0,0 +1,132 @@
+package compileopts
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestBuildTags(t *testing.T) {
+	tests := []struct {
+		targetTags []string
+		userTags   []string
+		result     []string
+	}{
+		{
+			targetTags: []string{},
+			userTags:   []string{},
+			result: []string{
+				"tinygo",
+				"math_big_pure_go",
+				"gc.conservative",
+				"scheduler.none",
+				"serial.none",
+			},
+		},
+		{
+			targetTags: []string{"bear"},
+			userTags:   []string{},
+			result: []string{
+				"bear",
+				"tinygo",
+				"math_big_pure_go",
+				"gc.conservative",
+				"scheduler.none",
+				"serial.none",
+			},
+		},
+		{
+			targetTags: []string{},
+			userTags:   []string{"cat"},
+			result: []string{
+				"tinygo",
+				"math_big_pure_go",
+				"gc.conservative",
+				"scheduler.none",
+				"serial.none",
+				"cat",
+			},
+		},
+		{
+			targetTags: []string{"bear"},
+			userTags:   []string{"cat"},
+			result: []string{
+				"bear",
+				"tinygo",
+				"math_big_pure_go",
+				"gc.conservative",
+				"scheduler.none",
+				"serial.none",
+				"cat",
+			},
+		},
+		{
+			targetTags: []string{"bear", "runtime_memhash_leveldb"},
+			userTags:   []string{"cat"},
+			result: []string{
+				"bear",
+				"runtime_memhash_leveldb",
+				"tinygo",
+				"math_big_pure_go",
+				"gc.conservative",
+				"scheduler.none",
+				"serial.none",
+				"cat",
+			},
+		},
+		{
+			targetTags: []string{"bear", "runtime_memhash_leveldb"},
+			userTags:   []string{"cat", "runtime_memhash_leveldb"},
+			result: []string{
+				"bear",
+				"tinygo",
+				"math_big_pure_go",
+				"gc.conservative",
+				"scheduler.none",
+				"serial.none",
+				"cat",
+				"runtime_memhash_leveldb",
+			},
+		},
+		{
+			targetTags: []string{"bear", "runtime_memhash_leveldb"},
+			userTags:   []string{"cat", "runtime_memhash_sip"},
+			result: []string{
+				"bear",
+				"tinygo",
+				"math_big_pure_go",
+				"gc.conservative",
+				"scheduler.none",
+				"serial.none",
+				"cat",
+				"runtime_memhash_sip",
+			},
+		},
+	}
+
+	for _, tc := range tests {
+		tt := tc
+		t.Run(fmt.Sprintf("%s+%s", strings.Join(tt.targetTags, ","), strings.Join(tt.userTags, ",")), func(t *testing.T) {
+			c := &Config{
+				Target: &TargetSpec{
+					BuildTags: tt.targetTags,
+				},
+				Options: &Options{
+					Tags: tt.userTags,
+				},
+			}
+
+			res := c.BuildTags()
+
+			if len(res) != len(tt.result) {
+				t.Errorf("expected %d tags, got %d", len(tt.result), len(res))
+			}
+
+			for i, tag := range tt.result {
+				if tag != res[i] {
+					t.Errorf("tag %d: expected %s, got %s", i, tt.result[i], tag)
+				}
+			}
+		})
+	}
+}

compileopts/target.go

@@ -326,9 +326,9 @@ func defaultTarget(goos, goarch, triple string) (*TargetSpec, error) {
 	}
 	if goarch != "wasm" {
 		suffix := ""
-		if goos == "windows" {
-			// Windows uses a different calling convention from other operating
-			// systems so we need separate assembly files.
+		if goos == "windows" && goarch == "amd64" {
+			// Windows uses a different calling convention on amd64 from other
+			// operating systems so we need separate assembly files.
 			suffix = "_windows"
 		}
 		spec.ExtraFiles = append(spec.ExtraFiles, "src/runtime/asm_"+goarch+suffix+".S")

compiler/atomic.go

@@ -13,8 +13,8 @@ import (
 func (b *builder) createAtomicOp(name string) llvm.Value {
 	switch name {
 	case "AddInt32", "AddInt64", "AddUint32", "AddUint64", "AddUintptr":
-		ptr := b.getValue(b.fn.Params[0])
-		val := b.getValue(b.fn.Params[1])
+		ptr := b.getValue(b.fn.Params[0], getPos(b.fn))
+		val := b.getValue(b.fn.Params[1], getPos(b.fn))
 		if strings.HasPrefix(b.Triple, "avr") {
 			// AtomicRMW does not work on AVR as intended:
 			// - There are some register allocation issues (fixed by https://reviews.llvm.org/D97127 which is not yet in a usable LLVM release)
@@ -33,8 +33,8 @@ func (b *builder) createAtomicOp(name string) llvm.Value {
 		// Return the new value, not the original value returned by atomicrmw.
 		return b.CreateAdd(oldVal, val, "")
 	case "SwapInt32", "SwapInt64", "SwapUint32", "SwapUint64", "SwapUintptr", "SwapPointer":
-		ptr := b.getValue(b.fn.Params[0])
-		val := b.getValue(b.fn.Params[1])
+		ptr := b.getValue(b.fn.Params[0], getPos(b.fn))
+		val := b.getValue(b.fn.Params[1], getPos(b.fn))
 		isPointer := val.Type().TypeKind() == llvm.PointerTypeKind
 		if isPointer {
 			// atomicrmw only supports integers, so cast to an integer.
@@ -48,21 +48,21 @@ func (b *builder) createAtomicOp(name string) llvm.Value {
 		}
 		return oldVal
 	case "CompareAndSwapInt32", "CompareAndSwapInt64", "CompareAndSwapUint32", "CompareAndSwapUint64", "CompareAndSwapUintptr", "CompareAndSwapPointer":
-		ptr := b.getValue(b.fn.Params[0])
-		old := b.getValue(b.fn.Params[1])
-		newVal := b.getValue(b.fn.Params[2])
+		ptr := b.getValue(b.fn.Params[0], getPos(b.fn))
+		old := b.getValue(b.fn.Params[1], getPos(b.fn))
+		newVal := b.getValue(b.fn.Params[2], getPos(b.fn))
 		tuple := b.CreateAtomicCmpXchg(ptr, old, newVal, llvm.AtomicOrderingSequentiallyConsistent, llvm.AtomicOrderingSequentiallyConsistent, true)
 		swapped := b.CreateExtractValue(tuple, 1, "")
 		return swapped
 	case "LoadInt32", "LoadInt64", "LoadUint32", "LoadUint64", "LoadUintptr", "LoadPointer":
-		ptr := b.getValue(b.fn.Params[0])
+		ptr := b.getValue(b.fn.Params[0], getPos(b.fn))
 		val := b.CreateLoad(b.getLLVMType(b.fn.Signature.Results().At(0).Type()), ptr, "")
 		val.SetOrdering(llvm.AtomicOrderingSequentiallyConsistent)
 		val.SetAlignment(b.targetData.PrefTypeAlignment(val.Type())) // required
 		return val
 	case "StoreInt32", "StoreInt64", "StoreUint32", "StoreUint64", "StoreUintptr", "StorePointer":
-		ptr := b.getValue(b.fn.Params[0])
-		val := b.getValue(b.fn.Params[1])
+		ptr := b.getValue(b.fn.Params[0], getPos(b.fn))
+		val := b.getValue(b.fn.Params[1], getPos(b.fn))
 		if strings.HasPrefix(b.Triple, "avr") {
 			// SelectionDAGBuilder is currently missing the "are unaligned atomics allowed" check for stores.
 			vType := val.Type()

compiler/channel.go

@@ -14,7 +14,7 @@ import (
 func (b *builder) createMakeChan(expr *ssa.MakeChan) llvm.Value {
 	elementSize := b.targetData.TypeAllocSize(b.getLLVMType(expr.Type().Underlying().(*types.Chan).Elem()))
 	elementSizeValue := llvm.ConstInt(b.uintptrType, elementSize, false)
-	bufSize := b.getValue(expr.Size)
+	bufSize := b.getValue(expr.Size, getPos(expr))
 	b.createChanBoundsCheck(elementSize, bufSize, expr.Size.Type().Underlying().(*types.Basic), expr.Pos())
 	if bufSize.Type().IntTypeWidth() < b.uintptrType.IntTypeWidth() {
 		bufSize = b.CreateZExt(bufSize, b.uintptrType, "")
@@ -27,8 +27,8 @@ func (b *builder) createMakeChan(expr *ssa.MakeChan) llvm.Value {
 // createChanSend emits a pseudo chan send operation. It is lowered to the
 // actual channel send operation during goroutine lowering.
 func (b *builder) createChanSend(instr *ssa.Send) {
-	ch := b.getValue(instr.Chan)
-	chanValue := b.getValue(instr.X)
+	ch := b.getValue(instr.Chan, getPos(instr))
+	chanValue := b.getValue(instr.X, getPos(instr))
 
 	// store value-to-send
 	valueType := b.getLLVMType(instr.X.Type())
@@ -62,7 +62,7 @@ func (b *builder) createChanSend(instr *ssa.Send) {
 // actual channel receive operation during goroutine lowering.
 func (b *builder) createChanRecv(unop *ssa.UnOp) llvm.Value {
 	valueType := b.getLLVMType(unop.X.Type().Underlying().(*types.Chan).Elem())
-	ch := b.getValue(unop.X)
+	ch := b.getValue(unop.X, getPos(unop))
 
 	// Allocate memory to receive into.
 	isZeroSize := b.targetData.TypeAllocSize(valueType) == 0
@@ -140,7 +140,7 @@ func (b *builder) createSelect(expr *ssa.Select) llvm.Value {
 	var selectStates []llvm.Value
 	chanSelectStateType := b.getLLVMRuntimeType("chanSelectState")
 	for _, state := range expr.States {
-		ch := b.getValue(state.Chan)
+		ch := b.getValue(state.Chan, state.Pos)
 		selectState := llvm.ConstNull(chanSelectStateType)
 		selectState = b.CreateInsertValue(selectState, ch, 0, "")
 		switch state.Dir {
@@ -156,7 +156,7 @@ func (b *builder) createSelect(expr *ssa.Select) llvm.Value {
 		case types.SendOnly:
 			// Store this value in an alloca and put a pointer to this alloca
 			// in the send state.
-			sendValue := b.getValue(state.Send)
+			sendValue := b.getValue(state.Send, state.Pos)
 			alloca := llvmutil.CreateEntryBlockAlloca(b.Builder, sendValue.Type(), "select.send.value")
 			b.CreateStore(sendValue, alloca)
 			ptr := b.CreateBitCast(alloca, b.i8ptrType, "")
@@ -247,7 +247,7 @@ func (b *builder) createSelect(expr *ssa.Select) llvm.Value {
 func (b *builder) getChanSelectResult(expr *ssa.Extract) llvm.Value {
 	if expr.Index == 0 {
 		// index
-		value := b.getValue(expr.Tuple)
+		value := b.getValue(expr.Tuple, getPos(expr))
 		index := b.CreateExtractValue(value, expr.Index, "")
 		if index.Type().IntTypeWidth() < b.intType.IntTypeWidth() {
 			index = b.CreateSExt(index, b.intType, "")
@@ -255,7 +255,7 @@ func (b *builder) getChanSelectResult(expr *ssa.Extract) llvm.Value {
 		return index
 	} else if expr.Index == 1 {
 		// comma-ok
-		value := b.getValue(expr.Tuple)
+		value := b.getValue(expr.Tuple, getPos(expr))
 		return b.CreateExtractValue(value, expr.Index, "")
 	} else {
 		// Select statements are (index, ok, ...) where ... is a number of

compiler/compiler.go

@@ -47,6 +47,7 @@ type Config struct {
 	CodeModel       string
 	RelocationModel string
 	SizeLevel       int
+	TinyGoVersion   string // for llvm.ident
 
 	// Various compiler options that determine how code is generated.
 	Scheduler          string
@@ -70,6 +71,7 @@ type compilerContext struct {
 	difiles          map[string]llvm.Metadata
 	ditypes          map[types.Type]llvm.Metadata
 	llvmTypes        typeutil.Map
+	interfaceTypes   typeutil.Map
 	machine          llvm.TargetMachine
 	targetData       llvm.TargetData
 	intType          llvm.Type
@@ -321,6 +323,14 @@ func CompilePackage(moduleName string, pkg *loader.Package, ssaPkg *ssa.Package,
 				llvm.ConstInt(c.ctx.Int32Type(), 4, false).ConstantAsMetadata(),
 			}),
 		)
+		if c.TinyGoVersion != "" {
+			// It is necessary to set llvm.ident, otherwise debugging on MacOS
+			// won't work.
+			c.mod.AddNamedMetadataOperand("llvm.ident",
+				c.ctx.MDNode(([]llvm.Metadata{
+					c.ctx.MDString("TinyGo version " + c.TinyGoVersion),
+				})))
+		}
 		c.dibuilder.Finalize()
 		c.dibuilder.Destroy()
 	}
@@ -340,12 +350,15 @@ func CompilePackage(moduleName string, pkg *loader.Package, ssaPkg *ssa.Package,
 	return c.mod, c.diagnostics
 }
 
+func (c *compilerContext) getRuntimeType(name string) types.Type {
+	return c.runtimePkg.Scope().Lookup(name).(*types.TypeName).Type()
+}
+
 // getLLVMRuntimeType obtains a named type from the runtime package and returns
 // it as a LLVM type, creating it if necessary. It is a shorthand for
 // getLLVMType(getRuntimeType(name)).
 func (c *compilerContext) getLLVMRuntimeType(name string) llvm.Type {
-	typ := c.runtimePkg.Scope().Lookup(name).(*types.TypeName).Type()
-	return c.getLLVMType(typ)
+	return c.getLLVMType(c.getRuntimeType(name))
 }
 
 // getLLVMType returns a LLVM type for a Go type. It doesn't recreate already
@@ -557,10 +570,19 @@ func (c *compilerContext) createDIType(typ types.Type) llvm.Metadata {
 	case *types.Map:
 		return c.getDIType(types.NewPointer(c.program.ImportedPackage("runtime").Members["hashmap"].(*ssa.Type).Type()))
 	case *types.Named:
-		return c.dibuilder.CreateTypedef(llvm.DITypedef{
+		// Placeholder metadata node, to be replaced afterwards.
+		temporaryMDNode := c.dibuilder.CreateReplaceableCompositeType(llvm.Metadata{}, llvm.DIReplaceableCompositeType{
+			Tag:         dwarf.TagTypedef,
+			SizeInBits:  sizeInBytes * 8,
+			AlignInBits: uint32(c.targetData.ABITypeAlignment(llvmType)) * 8,
+		})
+		c.ditypes[typ] = temporaryMDNode
+		md := c.dibuilder.CreateTypedef(llvm.DITypedef{
 			Type: c.getDIType(typ.Underlying()),
 			Name: typ.String(),
 		})
+		temporaryMDNode.ReplaceAllUsesWith(md)
+		return md
 	case *types.Pointer:
 		return c.dibuilder.CreatePointerType(llvm.DIPointerType{
 			Pointee:      c.getDIType(typ.Elem()),
@@ -622,13 +644,6 @@ func (c *compilerContext) createDIType(typ types.Type) llvm.Metadata {
 			},
 		})
 	case *types.Struct:
-		// Placeholder metadata node, to be replaced afterwards.
-		temporaryMDNode := c.dibuilder.CreateReplaceableCompositeType(llvm.Metadata{}, llvm.DIReplaceableCompositeType{
-			Tag:         dwarf.TagStructType,
-			SizeInBits:  sizeInBytes * 8,
-			AlignInBits: uint32(c.targetData.ABITypeAlignment(llvmType)) * 8,
-		})
-		c.ditypes[typ] = temporaryMDNode
 		elements := make([]llvm.Metadata, typ.NumFields())
 		for i := range elements {
 			field := typ.Field(i)
@@ -647,7 +662,6 @@ func (c *compilerContext) createDIType(typ types.Type) llvm.Metadata {
 			AlignInBits: uint32(c.targetData.ABITypeAlignment(llvmType)) * 8,
 			Elements:    elements,
 		})
-		temporaryMDNode.ReplaceAllUsesWith(md)
 		return md
 	case *types.TypeParam:
 		return c.getDIType(typ.Underlying())
@@ -831,6 +845,11 @@ func (c *compilerContext) createPackage(irbuilder llvm.Builder, pkg *ssa.Package
 				b.defineMathOp()
 				continue
 			}
+			if ok := b.defineMathBitsIntrinsic(); ok {
+				// Like a math intrinsic, the body of this function was replaced
+				// with a LLVM intrinsic.
+				continue
+			}
 			if member.Blocks == nil {
 				// Try to define this as an intrinsic function.
 				b.defineIntrinsicFunction()
@@ -857,14 +876,14 @@ func (c *compilerContext) createPackage(irbuilder llvm.Builder, pkg *ssa.Package
 				if fn == nil {
 					continue // probably a generic method
 				}
-				if fn.Blocks == nil {
-					continue // external function
-				}
 				if member.Type().String() != member.String() {
 					// This is a member on a type alias. Do not build such a
 					// function.
 					continue
 				}
+				if fn.Blocks == nil {
+					continue // external function
+				}
 				if fn.Synthetic != "" && fn.Synthetic != "package initializer" {
 					// This function is a kind of wrapper function (created by
 					// the ssa package, not appearing in the source code) that
@@ -958,6 +977,19 @@ func (c *compilerContext) createEmbedGlobal(member *ssa.Global, global llvm.Valu
 		global.SetInitializer(sliceObj)
 		global.SetVisibility(llvm.HiddenVisibility)
 
+		if c.Debug {
+			// Add debug info to the slice backing array.
+			position := c.program.Fset.Position(member.Pos())
+			diglobal := c.dibuilder.CreateGlobalVariableExpression(llvm.Metadata{}, llvm.DIGlobalVariableExpression{
+				File:        c.getDIFile(position.Filename),
+				Line:        position.Line,
+				Type:        c.getDIType(types.NewArray(types.Typ[types.Byte], int64(len(file.Data)))),
+				LocalToUnit: true,
+				Expr:        c.dibuilder.CreateExpression(nil),
+			})
+			bufferGlobal.AddMetadata(0, diglobal)
+		}
+
 	case *types.Struct:
 		// Assume this is an embed.FS struct:
 		// https://cs.opensource.google/go/go/+/refs/tags/go1.18.2:src/embed/embed.go;l=148
@@ -998,11 +1030,12 @@ func (c *compilerContext) createEmbedGlobal(member *ssa.Global, global llvm.Valu
 		})
 
 		// Make the backing array for the []files slice. This is a LLVM global.
-		embedFileStructType := c.getLLVMType(typ.Field(0).Type().(*types.Pointer).Elem().(*types.Slice).Elem())
+		embedFileStructType := typ.Field(0).Type().(*types.Pointer).Elem().(*types.Slice).Elem()
+		llvmEmbedFileStructType := c.getLLVMType(embedFileStructType)
 		var fileStructs []llvm.Value
 		for _, file := range allFiles {
-			fileStruct := llvm.ConstNull(embedFileStructType)
-			name := c.createConst(ssa.NewConst(constant.MakeString(file.Name), types.Typ[types.String]))
+			fileStruct := llvm.ConstNull(llvmEmbedFileStructType)
+			name := c.createConst(ssa.NewConst(constant.MakeString(file.Name), types.Typ[types.String]), getPos(member))
 			fileStruct = c.builder.CreateInsertValue(fileStruct, name, 0, "") // "name" field
 			if file.Hash != "" {
 				data := c.getEmbedFileString(file)
@@ -1010,13 +1043,25 @@ func (c *compilerContext) createEmbedGlobal(member *ssa.Global, global llvm.Valu
 			}
 			fileStructs = append(fileStructs, fileStruct)
 		}
-		sliceDataInitializer := llvm.ConstArray(embedFileStructType, fileStructs)
+		sliceDataInitializer := llvm.ConstArray(llvmEmbedFileStructType, fileStructs)
 		sliceDataGlobal := llvm.AddGlobal(c.mod, sliceDataInitializer.Type(), c.pkg.Path()+"$embedfsfiles")
 		sliceDataGlobal.SetInitializer(sliceDataInitializer)
 		sliceDataGlobal.SetLinkage(llvm.InternalLinkage)
 		sliceDataGlobal.SetGlobalConstant(true)
 		sliceDataGlobal.SetUnnamedAddr(true)
 		sliceDataGlobal.SetAlignment(c.targetData.ABITypeAlignment(sliceDataInitializer.Type()))
+		if c.Debug {
+			// Add debug information for code size attribution (among others).
+			position := c.program.Fset.Position(member.Pos())
+			diglobal := c.dibuilder.CreateGlobalVariableExpression(llvm.Metadata{}, llvm.DIGlobalVariableExpression{
+				File:        c.getDIFile(position.Filename),
+				Line:        position.Line,
+				Type:        c.getDIType(types.NewArray(embedFileStructType, int64(len(allFiles)))),
+				LocalToUnit: true,
+				Expr:        c.dibuilder.CreateExpression(nil),
+			})
+			sliceDataGlobal.AddMetadata(0, diglobal)
+		}
 
 		// Create the slice object itself.
 		// Because embed.FS refers to it as *[]embed.file instead of a plain
@@ -1033,6 +1078,17 @@ func (c *compilerContext) createEmbedGlobal(member *ssa.Global, global llvm.Valu
 		sliceGlobal.SetGlobalConstant(true)
 		sliceGlobal.SetUnnamedAddr(true)
 		sliceGlobal.SetAlignment(c.targetData.ABITypeAlignment(sliceInitializer.Type()))
+		if c.Debug {
+			position := c.program.Fset.Position(member.Pos())
+			diglobal := c.dibuilder.CreateGlobalVariableExpression(llvm.Metadata{}, llvm.DIGlobalVariableExpression{
+				File:        c.getDIFile(position.Filename),
+				Line:        position.Line,
+				Type:        c.getDIType(types.NewSlice(embedFileStructType)),
+				LocalToUnit: true,
+				Expr:        c.dibuilder.CreateExpression(nil),
+			})
+			sliceGlobal.AddMetadata(0, diglobal)
+		}
 
 		// Define the embed.FS struct. It has only one field: the files (as a
 		// *[]embed.file).
@@ -1272,7 +1328,7 @@ func (b *builder) createFunction() {
 				}
 				dbgVar := b.getLocalVariable(variable)
 				pos := b.program.Fset.Position(instr.Pos())
-				b.dibuilder.InsertValueAtEnd(b.getValue(instr.X), dbgVar, b.dibuilder.CreateExpression(nil), llvm.DebugLoc{
+				b.dibuilder.InsertValueAtEnd(b.getValue(instr.X, getPos(instr)), dbgVar, b.dibuilder.CreateExpression(nil), llvm.DebugLoc{
 					Line:  uint(pos.Line),
 					Col:   uint(pos.Column),
 					Scope: b.difunc,
@@ -1303,7 +1359,7 @@ func (b *builder) createFunction() {
 	for _, phi := range b.phis {
 		block := phi.ssa.Block()
 		for i, edge := range phi.ssa.Edges {
-			llvmVal := b.getValue(edge)
+			llvmVal := b.getValue(edge, getPos(phi.ssa))
 			llvmBlock := b.blockExits[block.Preds[i]]
 			phi.llvm.AddIncoming([]llvm.Value{llvmVal}, []llvm.BasicBlock{llvmBlock})
 		}
@@ -1411,7 +1467,7 @@ func (b *builder) createInstruction(instr ssa.Instruction) {
 		// Start a new goroutine.
 		b.createGo(instr)
 	case *ssa.If:
-		cond := b.getValue(instr.Cond)
+		cond := b.getValue(instr.Cond, getPos(instr))
 		block := instr.Block()
 		blockThen := b.blockEntries[block.Succs[0]]
 		blockElse := b.blockEntries[block.Succs[1]]
@@ -1420,13 +1476,13 @@ func (b *builder) createInstruction(instr ssa.Instruction) {
 		blockJump := b.blockEntries[instr.Block().Succs[0]]
 		b.CreateBr(blockJump)
 	case *ssa.MapUpdate:
-		m := b.getValue(instr.Map)
-		key := b.getValue(instr.Key)
-		value := b.getValue(instr.Value)
+		m := b.getValue(instr.Map, getPos(instr))
+		key := b.getValue(instr.Key, getPos(instr))
+		value := b.getValue(instr.Value, getPos(instr))
 		mapType := instr.Map.Type().Underlying().(*types.Map)
 		b.createMapUpdate(mapType.Key(), m, key, value, instr.Pos())
 	case *ssa.Panic:
-		value := b.getValue(instr.X)
+		value := b.getValue(instr.X, getPos(instr))
 		b.createRuntimeInvoke("_panic", []llvm.Value{value}, "")
 		b.CreateUnreachable()
 	case *ssa.Return:
@@ -1436,12 +1492,12 @@ func (b *builder) createInstruction(instr ssa.Instruction) {
 		if len(instr.Results) == 0 {
 			b.CreateRetVoid()
 		} else if len(instr.Results) == 1 {
-			b.CreateRet(b.getValue(instr.Results[0]))
+			b.CreateRet(b.getValue(instr.Results[0], getPos(instr)))
 		} else {
 			// Multiple return values. Put them all in a struct.
 			retVal := llvm.ConstNull(b.llvmFn.GlobalValueType().ReturnType())
 			for i, result := range instr.Results {
-				val := b.getValue(result)
+				val := b.getValue(result, getPos(instr))
 				retVal = b.CreateInsertValue(retVal, val, i, "")
 			}
 			b.CreateRet(retVal)
@@ -1451,8 +1507,8 @@ func (b *builder) createInstruction(instr ssa.Instruction) {
 	case *ssa.Send:
 		b.createChanSend(instr)
 	case *ssa.Store:
-		llvmAddr := b.getValue(instr.Addr)
-		llvmVal := b.getValue(instr.Val)
+		llvmAddr := b.getValue(instr.Addr, getPos(instr))
+		llvmVal := b.getValue(instr.Val, getPos(instr))
 		b.createNilCheck(instr.Addr, llvmAddr, "store")
 		if b.targetData.TypeAllocSize(llvmVal.Type()) == 0 {
 			// nothing to store
@@ -1711,7 +1767,7 @@ func (b *builder) createBuiltin(argTypes []types.Type, argValues []llvm.Value, c
 func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error) {
 	var params []llvm.Value
 	for _, param := range instr.Args {
-		params = append(params, b.getValue(param))
+		params = append(params, b.getValue(param, getPos(instr)))
 	}
 
 	// Try to call the function directly for trivially static calls.
@@ -1728,9 +1784,9 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 		case name == "device.AsmFull" || name == "device/arm.AsmFull" || name == "device/arm64.AsmFull" || name == "device/avr.AsmFull" || name == "device/riscv.AsmFull":
 			return b.createInlineAsmFull(instr)
 		case strings.HasPrefix(name, "device/arm.SVCall"):
-			return b.emitSVCall(instr.Args)
+			return b.emitSVCall(instr.Args, getPos(instr))
 		case strings.HasPrefix(name, "device/arm64.SVCall"):
-			return b.emitSV64Call(instr.Args)
+			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"):
@@ -1767,7 +1823,7 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 		case *ssa.MakeClosure:
 			// A call on a func value, but the callee is trivial to find. For
 			// example: immediately applied functions.
-			funcValue := b.getValue(value)
+			funcValue := b.getValue(value, getPos(value))
 			context = b.extractFuncContext(funcValue)
 		default:
 			panic("StaticCallee returned an unexpected value")
@@ -1782,7 +1838,7 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 		return b.createBuiltin(argTypes, params, call.Name(), instr.Pos())
 	} else if instr.IsInvoke() {
 		// Interface method call (aka invoke call).
-		itf := b.getValue(instr.Value) // interface value (runtime._interface)
+		itf := b.getValue(instr.Value, getPos(instr)) // interface value (runtime._interface)
 		typecode := b.CreateExtractValue(itf, 0, "invoke.func.typecode")
 		value := b.CreateExtractValue(itf, 1, "invoke.func.value") // receiver
 		// Prefix the params with receiver value and suffix with typecode.
@@ -1793,7 +1849,7 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 		context = llvm.Undef(b.i8ptrType)
 	} else {
 		// Function pointer.
-		value := b.getValue(instr.Value)
+		value := b.getValue(instr.Value, getPos(instr))
 		// This is a func value, which cannot be called directly. We have to
 		// extract the function pointer and context first from the func value.
 		calleeType, callee, context = b.decodeFuncValue(value, instr.Value.Type().Underlying().(*types.Signature))
@@ -1811,10 +1867,18 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 
 // getValue returns the LLVM value of a constant, function value, global, or
 // already processed SSA expression.
-func (b *builder) getValue(expr ssa.Value) llvm.Value {
+func (b *builder) getValue(expr ssa.Value, pos token.Pos) llvm.Value {
 	switch expr := expr.(type) {
 	case *ssa.Const:
-		return b.createConst(expr)
+		if pos == token.NoPos {
+			// If the position isn't known, at least try to find in which file
+			// it is defined.
+			file := b.program.Fset.File(b.fn.Pos())
+			if file != nil {
+				pos = file.Pos(0)
+			}
+		}
+		return b.createConst(expr, pos)
 	case *ssa.Function:
 		if b.getFunctionInfo(expr).exported {
 			b.addError(expr.Pos(), "cannot use an exported function as value: "+expr.String())
@@ -1899,8 +1963,8 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 			return buf, nil
 		}
 	case *ssa.BinOp:
-		x := b.getValue(expr.X)
-		y := b.getValue(expr.Y)
+		x := b.getValue(expr.X, getPos(expr))
+		y := b.getValue(expr.Y, getPos(expr))
 		return b.createBinOp(expr.Op, expr.X.Type(), expr.Y.Type(), x, y, expr.Pos())
 	case *ssa.Call:
 		return b.createFunctionCall(expr.Common())
@@ -1911,12 +1975,12 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 		// This is different from how the official Go compiler works, because of
 		// heap allocation and because it's easier to implement, see:
 		// https://research.swtch.com/interfaces
-		return b.getValue(expr.X), nil
+		return b.getValue(expr.X, getPos(expr)), nil
 	case *ssa.ChangeType:
 		// This instruction changes the type, but the underlying value remains
 		// the same. This is often a no-op, but sometimes we have to change the
 		// LLVM type as well.
-		x := b.getValue(expr.X)
+		x := b.getValue(expr.X, getPos(expr))
 		llvmType := b.getLLVMType(expr.Type())
 		if x.Type() == llvmType {
 			// Different Go type but same LLVM type (for example, named int).
@@ -1945,20 +2009,20 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 	case *ssa.Const:
 		panic("const is not an expression")
 	case *ssa.Convert:
-		x := b.getValue(expr.X)
+		x := b.getValue(expr.X, getPos(expr))
 		return b.createConvert(expr.X.Type(), expr.Type(), x, expr.Pos())
 	case *ssa.Extract:
 		if _, ok := expr.Tuple.(*ssa.Select); ok {
 			return b.getChanSelectResult(expr), nil
 		}
-		value := b.getValue(expr.Tuple)
+		value := b.getValue(expr.Tuple, getPos(expr))
 		return b.CreateExtractValue(value, expr.Index, ""), nil
 	case *ssa.Field:
-		value := b.getValue(expr.X)
+		value := b.getValue(expr.X, getPos(expr))
 		result := b.CreateExtractValue(value, expr.Field, "")
 		return result, nil
 	case *ssa.FieldAddr:
-		val := b.getValue(expr.X)
+		val := b.getValue(expr.X, getPos(expr))
 		// Check for nil pointer before calculating the address, from the spec:
 		// > For an operand x of type T, the address operation &x generates a
 		// > pointer of type *T to x. [...] If the evaluation of x would cause a
@@ -1976,8 +2040,8 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 	case *ssa.Global:
 		panic("global is not an expression")
 	case *ssa.Index:
-		collection := b.getValue(expr.X)
-		index := b.getValue(expr.Index)
+		collection := b.getValue(expr.X, getPos(expr))
+		index := b.getValue(expr.Index, getPos(expr))
 
 		switch xType := expr.X.Type().Underlying().(type) {
 		case *types.Basic: // extract byte from string
@@ -2026,8 +2090,8 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 			panic("unknown *ssa.Index type")
 		}
 	case *ssa.IndexAddr:
-		val := b.getValue(expr.X)
-		index := b.getValue(expr.Index)
+		val := b.getValue(expr.X, getPos(expr))
+		index := b.getValue(expr.Index, getPos(expr))
 
 		// Get buffer pointer and length
 		var bufptr, buflen llvm.Value
@@ -2078,8 +2142,8 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 			panic("unreachable")
 		}
 	case *ssa.Lookup: // map lookup
-		value := b.getValue(expr.X)
-		index := b.getValue(expr.Index)
+		value := b.getValue(expr.X, getPos(expr))
+		index := b.getValue(expr.Index, getPos(expr))
 		valueType := expr.Type()
 		if expr.CommaOk {
 			valueType = valueType.(*types.Tuple).At(0).Type()
@@ -2090,13 +2154,13 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 	case *ssa.MakeClosure:
 		return b.parseMakeClosure(expr)
 	case *ssa.MakeInterface:
-		val := b.getValue(expr.X)
+		val := b.getValue(expr.X, getPos(expr))
 		return b.createMakeInterface(val, expr.X.Type(), expr.Pos()), nil
 	case *ssa.MakeMap:
 		return b.createMakeMap(expr)
 	case *ssa.MakeSlice:
-		sliceLen := b.getValue(expr.Len)
-		sliceCap := b.getValue(expr.Cap)
+		sliceLen := b.getValue(expr.Len, getPos(expr))
+		sliceCap := b.getValue(expr.Cap, getPos(expr))
 		sliceType := expr.Type().Underlying().(*types.Slice)
 		llvmElemType := b.getLLVMType(sliceType.Elem())
 		elemSize := b.targetData.TypeAllocSize(llvmElemType)
@@ -2148,8 +2212,8 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 		return slice, nil
 	case *ssa.Next:
 		rangeVal := expr.Iter.(*ssa.Range).X
-		llvmRangeVal := b.getValue(rangeVal)
-		it := b.getValue(expr.Iter)
+		llvmRangeVal := b.getValue(rangeVal, getPos(expr))
+		it := b.getValue(expr.Iter, getPos(expr))
 		if expr.IsString {
 			return b.createRuntimeCall("stringNext", []llvm.Value{llvmRangeVal, it}, "range.next"), nil
 		} else { // map
@@ -2175,14 +2239,14 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 	case *ssa.Select:
 		return b.createSelect(expr), nil
 	case *ssa.Slice:
-		value := b.getValue(expr.X)
+		value := b.getValue(expr.X, getPos(expr))
 
 		var lowType, highType, maxType *types.Basic
 		var low, high, max llvm.Value
 
 		if expr.Low != nil {
 			lowType = expr.Low.Type().Underlying().(*types.Basic)
-			low = b.getValue(expr.Low)
+			low = b.getValue(expr.Low, getPos(expr))
 			low = b.extendInteger(low, lowType, b.uintptrType)
 		} else {
 			lowType = types.Typ[types.Uintptr]
@@ -2191,7 +2255,7 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 
 		if expr.High != nil {
 			highType = expr.High.Type().Underlying().(*types.Basic)
-			high = b.getValue(expr.High)
+			high = b.getValue(expr.High, getPos(expr))
 			high = b.extendInteger(high, highType, b.uintptrType)
 		} else {
 			highType = types.Typ[types.Uintptr]
@@ -2199,7 +2263,7 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 
 		if expr.Max != nil {
 			maxType = expr.Max.Type().Underlying().(*types.Basic)
-			max = b.getValue(expr.Max)
+			max = b.getValue(expr.Max, getPos(expr))
 			max = b.extendInteger(max, maxType, b.uintptrType)
 		} else {
 			maxType = types.Typ[types.Uintptr]
@@ -2332,7 +2396,7 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 		// Conversion from a slice to an array pointer, as the name clearly
 		// says. This requires a runtime check to make sure the slice is at
 		// least as big as the array.
-		slice := b.getValue(expr.X)
+		slice := b.getValue(expr.X, getPos(expr))
 		sliceLen := b.CreateExtractValue(slice, 1, "")
 		arrayLen := expr.Type().Underlying().(*types.Pointer).Elem().Underlying().(*types.Array).Len()
 		b.createSliceToArrayPointerCheck(sliceLen, arrayLen)
@@ -2765,7 +2829,7 @@ func (b *builder) createBinOp(op token.Token, typ, ytyp types.Type, x, y llvm.Va
 }
 
 // createConst creates a LLVM constant value from a Go constant.
-func (c *compilerContext) createConst(expr *ssa.Const) llvm.Value {
+func (c *compilerContext) createConst(expr *ssa.Const, pos token.Pos) llvm.Value {
 	switch typ := expr.Type().Underlying().(type) {
 	case *types.Basic:
 		llvmType := c.getLLVMType(typ)
@@ -2788,6 +2852,18 @@ func (c *compilerContext) createConst(expr *ssa.Const) llvm.Value {
 				global.SetGlobalConstant(true)
 				global.SetUnnamedAddr(true)
 				global.SetAlignment(1)
+				if c.Debug {
+					// Unfortunately, expr.Pos() is always token.NoPos.
+					position := c.program.Fset.Position(pos)
+					diglobal := c.dibuilder.CreateGlobalVariableExpression(llvm.Metadata{}, llvm.DIGlobalVariableExpression{
+						File:        c.getDIFile(position.Filename),
+						Line:        position.Line,
+						Type:        c.getDIType(types.NewArray(types.Typ[types.Byte], int64(len(str)))),
+						LocalToUnit: true,
+						Expr:        c.dibuilder.CreateExpression(nil),
+					})
+					global.AddMetadata(0, diglobal)
+				}
 				zero := llvm.ConstInt(c.ctx.Int32Type(), 0, false)
 				strPtr = llvm.ConstInBoundsGEP(globalType, global, []llvm.Value{zero, zero})
 			} else {
@@ -2811,15 +2887,15 @@ func (c *compilerContext) createConst(expr *ssa.Const) llvm.Value {
 			n, _ := constant.Float64Val(expr.Value)
 			return llvm.ConstFloat(llvmType, n)
 		} else if typ.Kind() == types.Complex64 {
-			r := c.createConst(ssa.NewConst(constant.Real(expr.Value), types.Typ[types.Float32]))
-			i := c.createConst(ssa.NewConst(constant.Imag(expr.Value), types.Typ[types.Float32]))
+			r := c.createConst(ssa.NewConst(constant.Real(expr.Value), types.Typ[types.Float32]), pos)
+			i := c.createConst(ssa.NewConst(constant.Imag(expr.Value), types.Typ[types.Float32]), pos)
 			cplx := llvm.Undef(c.ctx.StructType([]llvm.Type{c.ctx.FloatType(), c.ctx.FloatType()}, false))
 			cplx = c.builder.CreateInsertValue(cplx, r, 0, "")
 			cplx = c.builder.CreateInsertValue(cplx, i, 1, "")
 			return cplx
 		} else if typ.Kind() == types.Complex128 {
-			r := c.createConst(ssa.NewConst(constant.Real(expr.Value), types.Typ[types.Float64]))
-			i := c.createConst(ssa.NewConst(constant.Imag(expr.Value), types.Typ[types.Float64]))
+			r := c.createConst(ssa.NewConst(constant.Real(expr.Value), types.Typ[types.Float64]), pos)
+			i := c.createConst(ssa.NewConst(constant.Imag(expr.Value), types.Typ[types.Float64]), pos)
 			cplx := llvm.Undef(c.ctx.StructType([]llvm.Type{c.ctx.DoubleType(), c.ctx.DoubleType()}, false))
 			cplx = c.builder.CreateInsertValue(cplx, r, 0, "")
 			cplx = c.builder.CreateInsertValue(cplx, i, 1, "")
@@ -2888,31 +2964,6 @@ func (b *builder) createConvert(typeFrom, typeTo types.Type, value llvm.Value, p
 	if isPtrFrom && !isPtrTo {
 		return b.CreatePtrToInt(value, llvmTypeTo, ""), nil
 	} else if !isPtrFrom && isPtrTo {
-		if !value.IsABinaryOperator().IsNil() && value.InstructionOpcode() == llvm.Add {
-			// This is probably a pattern like the following:
-			// unsafe.Pointer(uintptr(ptr) + index)
-			// Used in functions like memmove etc. for lack of pointer
-			// arithmetic. Convert it to real pointer arithmatic here.
-			ptr := value.Operand(0)
-			index := value.Operand(1)
-			if !index.IsAPtrToIntInst().IsNil() {
-				// Swap if necessary, if ptr and index are reversed.
-				ptr, index = index, ptr
-			}
-			if !ptr.IsAPtrToIntInst().IsNil() {
-				origptr := ptr.Operand(0)
-				if origptr.Type() == b.i8ptrType {
-					// This pointer can be calculated from the original
-					// ptrtoint instruction with a GEP. The leftover inttoptr
-					// instruction is trivial to optimize away.
-					// Making it an in bounds GEP even though it's easy to
-					// create a GEP that is not in bounds. However, we're
-					// talking about unsafe code here so the programmer has to
-					// be careful anyway.
-					return b.CreateInBoundsGEP(b.ctx.Int8Type(), origptr, []llvm.Value{index}, ""), nil
-				}
-			}
-		}
 		return b.CreateIntToPtr(value, llvmTypeTo, ""), nil
 	}
 
@@ -3115,7 +3166,7 @@ func (b *builder) createConvert(typeFrom, typeTo types.Type, value llvm.Value, p
 // which can all be directly lowered to IR. However, there is also the channel
 // receive operator which is handled in the runtime directly.
 func (b *builder) createUnOp(unop *ssa.UnOp) (llvm.Value, error) {
-	x := b.getValue(unop.X)
+	x := b.getValue(unop.X, getPos(unop))
 	switch unop.Op {
 	case token.NOT: // !x
 		return b.CreateNot(x, ""), nil

compiler/compiler_test.go

@@ -49,6 +49,7 @@ func TestCompiler(t *testing.T) {
 		{"goroutine.go", "cortex-m-qemu", "tasks"},
 		{"channel.go", "", ""},
 		{"gc.go", "", ""},
+		{"zeromap.go", "", ""},
 	}
 	if goMinor >= 20 {
 		tests = append(tests, testCase{"go1.20.go", "", ""})

compiler/defer.go

@@ -267,13 +267,13 @@ func (b *builder) createDefer(instr *ssa.Defer) {
 
 		// Collect all values to be put in the struct (starting with
 		// runtime._defer fields, followed by the call parameters).
-		itf := b.getValue(instr.Call.Value) // interface
+		itf := b.getValue(instr.Call.Value, getPos(instr)) // interface
 		typecode := b.CreateExtractValue(itf, 0, "invoke.func.typecode")
 		receiverValue := b.CreateExtractValue(itf, 1, "invoke.func.receiver")
 		values = []llvm.Value{callback, next, typecode, receiverValue}
-		valueTypes = append(valueTypes, b.uintptrType, b.i8ptrType)
+		valueTypes = append(valueTypes, b.i8ptrType, b.i8ptrType)
 		for _, arg := range instr.Call.Args {
-			val := b.getValue(arg)
+			val := b.getValue(arg, getPos(instr))
 			values = append(values, val)
 			valueTypes = append(valueTypes, val.Type())
 		}
@@ -290,7 +290,7 @@ func (b *builder) createDefer(instr *ssa.Defer) {
 		// runtime._defer fields).
 		values = []llvm.Value{callback, next}
 		for _, param := range instr.Call.Args {
-			llvmParam := b.getValue(param)
+			llvmParam := b.getValue(param, getPos(instr))
 			values = append(values, llvmParam)
 			valueTypes = append(valueTypes, llvmParam.Type())
 		}
@@ -302,7 +302,7 @@ func (b *builder) createDefer(instr *ssa.Defer) {
 		// pointer.
 		// TODO: ignore this closure entirely and put pointers to the free
 		// variables directly in the defer struct, avoiding a memory allocation.
-		closure := b.getValue(instr.Call.Value)
+		closure := b.getValue(instr.Call.Value, getPos(instr))
 		context := b.CreateExtractValue(closure, 0, "")
 
 		// Get the callback number.
@@ -318,7 +318,7 @@ func (b *builder) createDefer(instr *ssa.Defer) {
 		// context pointer).
 		values = []llvm.Value{callback, next}
 		for _, param := range instr.Call.Args {
-			llvmParam := b.getValue(param)
+			llvmParam := b.getValue(param, getPos(instr))
 			values = append(values, llvmParam)
 			valueTypes = append(valueTypes, llvmParam.Type())
 		}
@@ -330,7 +330,7 @@ func (b *builder) createDefer(instr *ssa.Defer) {
 		var argValues []llvm.Value
 		for _, arg := range instr.Call.Args {
 			argTypes = append(argTypes, arg.Type())
-			argValues = append(argValues, b.getValue(arg))
+			argValues = append(argValues, b.getValue(arg, getPos(instr)))
 		}
 
 		if _, ok := b.deferBuiltinFuncs[instr.Call.Value]; !ok {
@@ -353,7 +353,7 @@ func (b *builder) createDefer(instr *ssa.Defer) {
 		}
 
 	} else {
-		funcValue := b.getValue(instr.Call.Value)
+		funcValue := b.getValue(instr.Call.Value, getPos(instr))
 
 		if _, ok := b.deferExprFuncs[instr.Call.Value]; !ok {
 			b.deferExprFuncs[instr.Call.Value] = len(b.allDeferFuncs)
@@ -368,7 +368,7 @@ func (b *builder) createDefer(instr *ssa.Defer) {
 		values = []llvm.Value{callback, next, funcValue}
 		valueTypes = append(valueTypes, funcValue.Type())
 		for _, param := range instr.Call.Args {
-			llvmParam := b.getValue(param)
+			llvmParam := b.getValue(param, getPos(instr))
 			values = append(values, llvmParam)
 			valueTypes = append(valueTypes, llvmParam.Type())
 		}
@@ -476,7 +476,7 @@ func (b *builder) createRunDefers() {
 				valueTypes = append(valueTypes, b.getFuncType(callback.Signature()))
 			} else {
 				//Expect typecode
-				valueTypes = append(valueTypes, b.uintptrType, b.i8ptrType)
+				valueTypes = append(valueTypes, b.i8ptrType, b.i8ptrType)
 			}
 
 			for _, arg := range callback.Args {
@@ -544,7 +544,7 @@ func (b *builder) createRunDefers() {
 				forwardParams = append(forwardParams, forwardParam)
 			}
 
-			// Plain TinyGo functions add some extra parameters to implement async functionality and function recievers.
+			// Plain TinyGo functions add some extra parameters to implement async functionality and function receivers.
 			// These parameters should not be supplied when calling into an external C/ASM function.
 			if !b.getFunctionInfo(callback).exported {
 				// Add the context parameter. We know it is ignored by the receiving

compiler/func.go

@@ -32,7 +32,8 @@ func (c *compilerContext) createFuncValue(builder llvm.Builder, funcPtr, context
 // global reference is not real, it is only used during func lowering to assign
 // signature types to functions and will then be removed.
 func (c *compilerContext) getFuncSignatureID(sig *types.Signature) llvm.Value {
-	sigGlobalName := "reflect/types.funcid:" + getTypeCodeName(sig)
+	s, _ := getTypeCodeName(sig)
+	sigGlobalName := "reflect/types.funcid:" + s
 	sigGlobal := c.mod.NamedGlobal(sigGlobalName)
 	if sigGlobal.IsNil() {
 		sigGlobal = llvm.AddGlobal(c.mod, c.ctx.Int8Type(), sigGlobalName)
@@ -134,7 +135,7 @@ func (b *builder) parseMakeClosure(expr *ssa.MakeClosure) (llvm.Value, error) {
 	boundVars := make([]llvm.Value, len(expr.Bindings))
 	for i, binding := range expr.Bindings {
 		// The context stores the bound variables.
-		llvmBoundVar := b.getValue(binding)
+		llvmBoundVar := b.getValue(binding, getPos(expr))
 		boundVars[i] = llvmBoundVar
 	}
 

compiler/goroutine.go

@@ -16,7 +16,7 @@ func (b *builder) createGo(instr *ssa.Go) {
 	// Get all function parameters to pass to the goroutine.
 	var params []llvm.Value
 	for _, param := range instr.Call.Args {
-		params = append(params, b.getValue(param))
+		params = append(params, b.getValue(param, getPos(instr)))
 	}
 
 	var prefix string
@@ -33,7 +33,7 @@ func (b *builder) createGo(instr *ssa.Go) {
 		case *ssa.MakeClosure:
 			// A goroutine call on a func value, but the callee is trivial to find. For
 			// example: immediately applied functions.
-			funcValue := b.getValue(value)
+			funcValue := b.getValue(value, getPos(instr))
 			context = b.extractFuncContext(funcValue)
 		default:
 			panic("StaticCallee returned an unexpected value")
@@ -70,13 +70,13 @@ func (b *builder) createGo(instr *ssa.Go) {
 		var argValues []llvm.Value
 		for _, arg := range instr.Call.Args {
 			argTypes = append(argTypes, arg.Type())
-			argValues = append(argValues, b.getValue(arg))
+			argValues = append(argValues, b.getValue(arg, getPos(instr)))
 		}
 		b.createBuiltin(argTypes, argValues, builtin.Name(), instr.Pos())
 		return
 	} else if instr.Call.IsInvoke() {
 		// This is a method call on an interface value.
-		itf := b.getValue(instr.Call.Value)
+		itf := b.getValue(instr.Call.Value, getPos(instr))
 		itfTypeCode := b.CreateExtractValue(itf, 0, "")
 		itfValue := b.CreateExtractValue(itf, 1, "")
 		funcPtr = b.getInvokeFunction(&instr.Call)
@@ -90,7 +90,7 @@ func (b *builder) createGo(instr *ssa.Go) {
 		//   * The function context, for closures.
 		//   * The function pointer (for tasks).
 		var context llvm.Value
-		funcPtrType, funcPtr, context = b.decodeFuncValue(b.getValue(instr.Call.Value), instr.Call.Value.Type().Underlying().(*types.Signature))
+		funcPtrType, funcPtr, context = b.decodeFuncValue(b.getValue(instr.Call.Value, getPos(instr)), instr.Call.Value.Type().Underlying().(*types.Signature))
 		params = append(params, context, funcPtr)
 		hasContext = true
 		prefix = b.fn.RelString(nil)

compiler/inlineasm.go

@@ -5,6 +5,7 @@ package compiler
 import (
 	"fmt"
 	"go/constant"
+	"go/token"
 	"regexp"
 	"strconv"
 	"strings"
@@ -55,7 +56,7 @@ func (b *builder) createInlineAsmFull(instr *ssa.CallCommon) (llvm.Value, error)
 					return llvm.Value{}, b.makeError(instr.Pos(), "register value map must be created in the same basic block")
 				}
 				key := constant.StringVal(r.Key.(*ssa.Const).Value)
-				registers[key] = b.getValue(r.Value.(*ssa.MakeInterface).X)
+				registers[key] = b.getValue(r.Value.(*ssa.MakeInterface).X, getPos(instr))
 			case *ssa.Call:
 				if r.Common() == instr {
 					break
@@ -140,7 +141,7 @@ func (b *builder) createInlineAsmFull(instr *ssa.CallCommon) (llvm.Value, error)
 //
 // The num parameter must be a constant. All other parameters may be any scalar
 // value supported by LLVM inline assembly.
-func (b *builder) emitSVCall(args []ssa.Value) (llvm.Value, error) {
+func (b *builder) emitSVCall(args []ssa.Value, pos token.Pos) (llvm.Value, error) {
 	num, _ := constant.Uint64Val(args[0].(*ssa.Const).Value)
 	llvmArgs := []llvm.Value{}
 	argTypes := []llvm.Type{}
@@ -153,7 +154,7 @@ func (b *builder) emitSVCall(args []ssa.Value) (llvm.Value, error) {
 		} else {
 			constraints += ",{r" + strconv.Itoa(i) + "}"
 		}
-		llvmValue := b.getValue(arg)
+		llvmValue := b.getValue(arg, pos)
 		llvmArgs = append(llvmArgs, llvmValue)
 		argTypes = append(argTypes, llvmValue.Type())
 	}
@@ -178,7 +179,7 @@ func (b *builder) emitSVCall(args []ssa.Value) (llvm.Value, error) {
 // The num parameter must be a constant. All other parameters may be any scalar
 // value supported by LLVM inline assembly.
 // Same as emitSVCall but for AArch64
-func (b *builder) emitSV64Call(args []ssa.Value) (llvm.Value, error) {
+func (b *builder) emitSV64Call(args []ssa.Value, pos token.Pos) (llvm.Value, error) {
 	num, _ := constant.Uint64Val(args[0].(*ssa.Const).Value)
 	llvmArgs := []llvm.Value{}
 	argTypes := []llvm.Type{}
@@ -191,7 +192,7 @@ func (b *builder) emitSV64Call(args []ssa.Value) (llvm.Value, error) {
 		} else {
 			constraints += ",{x" + strconv.Itoa(i) + "}"
 		}
-		llvmValue := b.getValue(arg)
+		llvmValue := b.getValue(arg, pos)
 		llvmArgs = append(llvmArgs, llvmValue)
 		argTypes = append(argTypes, llvmValue.Type())
 	}
@@ -231,19 +232,19 @@ func (b *builder) emitCSROperation(call *ssa.CallCommon) (llvm.Value, error) {
 		fnType := llvm.FunctionType(b.ctx.VoidType(), []llvm.Type{b.uintptrType}, false)
 		asm := fmt.Sprintf("csrw %d, $0", csr)
 		target := llvm.InlineAsm(fnType, asm, "r", true, false, 0, false)
-		return b.CreateCall(fnType, target, []llvm.Value{b.getValue(call.Args[1])}, ""), nil
+		return b.CreateCall(fnType, target, []llvm.Value{b.getValue(call.Args[1], getPos(call))}, ""), nil
 	case "SetBits":
 		// Note: it may be possible to optimize this to csrrsi in many cases.
 		fnType := llvm.FunctionType(b.uintptrType, []llvm.Type{b.uintptrType}, false)
 		asm := fmt.Sprintf("csrrs $0, %d, $1", csr)
 		target := llvm.InlineAsm(fnType, asm, "=r,r", true, false, 0, false)
-		return b.CreateCall(fnType, target, []llvm.Value{b.getValue(call.Args[1])}, ""), nil
+		return b.CreateCall(fnType, target, []llvm.Value{b.getValue(call.Args[1], getPos(call))}, ""), nil
 	case "ClearBits":
 		// Note: it may be possible to optimize this to csrrci in many cases.
 		fnType := llvm.FunctionType(b.uintptrType, []llvm.Type{b.uintptrType}, false)
 		asm := fmt.Sprintf("csrrc $0, %d, $1", csr)
 		target := llvm.InlineAsm(fnType, asm, "=r,r", true, false, 0, false)
-		return b.CreateCall(fnType, target, []llvm.Value{b.getValue(call.Args[1])}, ""), nil
+		return b.CreateCall(fnType, target, []llvm.Value{b.getValue(call.Args[1], getPos(call))}, ""), nil
 	default:
 		return llvm.Value{}, b.makeError(call.Pos(), "unknown CSR operation: "+name)
 	}

compiler/interface.go

@@ -6,6 +6,7 @@ package compiler
 // interface-lowering.go for more details.
 
 import (
+	"fmt"
 	"go/token"
 	"go/types"
 	"strconv"
@@ -15,6 +16,58 @@ import (
 	"tinygo.org/x/go-llvm"
 )
 
+// Type kinds for basic types.
+// They must match the constants for the Kind type in src/reflect/type.go.
+var basicTypes = [...]uint8{
+	types.Bool:          1,
+	types.Int:           2,
+	types.Int8:          3,
+	types.Int16:         4,
+	types.Int32:         5,
+	types.Int64:         6,
+	types.Uint:          7,
+	types.Uint8:         8,
+	types.Uint16:        9,
+	types.Uint32:        10,
+	types.Uint64:        11,
+	types.Uintptr:       12,
+	types.Float32:       13,
+	types.Float64:       14,
+	types.Complex64:     15,
+	types.Complex128:    16,
+	types.String:        17,
+	types.UnsafePointer: 18,
+}
+
+// These must also match the constants for the Kind type in src/reflect/type.go.
+const (
+	typeKindChan      = 19
+	typeKindInterface = 20
+	typeKindPointer   = 21
+	typeKindSlice     = 22
+	typeKindArray     = 23
+	typeKindSignature = 24
+	typeKindMap       = 25
+	typeKindStruct    = 26
+)
+
+// Flags stored in the first byte of the struct field byte array. Must be kept
+// up to date with src/reflect/type.go.
+const (
+	structFieldFlagAnonymous = 1 << iota
+	structFieldFlagHasTag
+	structFieldFlagIsExported
+	structFieldFlagIsEmbedded
+)
+
+type reflectChanDir int
+
+const (
+	refRecvDir reflectChanDir            = 1 << iota // <-chan
+	refSendDir                                       // chan<-
+	refBothDir = refRecvDir | refSendDir             // chan
+)
+
 // createMakeInterface emits the LLVM IR for the *ssa.MakeInterface instruction.
 // It tries to put the type in the interface value, but if that's not possible,
 // it will do an allocation of the right size and put that in the interface
@@ -23,10 +76,9 @@ import (
 // An interface value is a {typecode, value} tuple named runtime._interface.
 func (b *builder) createMakeInterface(val llvm.Value, typ types.Type, pos token.Pos) llvm.Value {
 	itfValue := b.emitPointerPack([]llvm.Value{val})
-	itfTypeCodeGlobal := b.getTypeCode(typ)
-	itfTypeCode := b.CreatePtrToInt(itfTypeCodeGlobal, b.uintptrType, "")
+	itfType := b.getTypeCode(typ)
 	itf := llvm.Undef(b.getLLVMRuntimeType("_interface"))
-	itf = b.CreateInsertValue(itf, itfTypeCode, 0, "")
+	itf = b.CreateInsertValue(itf, itfType, 0, "")
 	itf = b.CreateInsertValue(itf, itfValue, 1, "")
 	return itf
 }
@@ -40,119 +92,348 @@ func (b *builder) extractValueFromInterface(itf llvm.Value, llvmType llvm.Type)
 	return b.emitPointerUnpack(valuePtr, []llvm.Type{llvmType})[0]
 }
 
+func (c *compilerContext) pkgPathPtr(pkgpath string) llvm.Value {
+	pkgpathName := "reflect/types.type.pkgpath.empty"
+	if pkgpath != "" {
+		pkgpathName = "reflect/types.type.pkgpath:" + pkgpath
+	}
+
+	pkgpathGlobal := c.mod.NamedGlobal(pkgpathName)
+	if pkgpathGlobal.IsNil() {
+		pkgpathInitializer := c.ctx.ConstString(pkgpath+"\x00", false)
+		pkgpathGlobal = llvm.AddGlobal(c.mod, pkgpathInitializer.Type(), pkgpathName)
+		pkgpathGlobal.SetInitializer(pkgpathInitializer)
+		pkgpathGlobal.SetAlignment(1)
+		pkgpathGlobal.SetUnnamedAddr(true)
+		pkgpathGlobal.SetLinkage(llvm.LinkOnceODRLinkage)
+		pkgpathGlobal.SetGlobalConstant(true)
+	}
+	pkgPathPtr := llvm.ConstGEP(pkgpathGlobal.GlobalValueType(), pkgpathGlobal, []llvm.Value{
+		llvm.ConstInt(c.ctx.Int32Type(), 0, false),
+		llvm.ConstInt(c.ctx.Int32Type(), 0, false),
+	})
+
+	return pkgPathPtr
+}
+
 // getTypeCode returns a reference to a type code.
-// It returns a pointer to an external global which should be replaced with the
-// real type in the interface lowering pass.
+// A type code is a pointer to a constant global that describes the type.
+// This function returns a pointer to the 'kind' field (which might not be the
+// first field in the struct).
 func (c *compilerContext) getTypeCode(typ types.Type) llvm.Value {
-	globalName := "reflect/types.type:" + getTypeCodeName(typ)
-	global := c.mod.NamedGlobal(globalName)
+	ms := c.program.MethodSets.MethodSet(typ)
+	hasMethodSet := ms.Len() != 0
+	if _, ok := typ.Underlying().(*types.Interface); ok {
+		hasMethodSet = false
+	}
+	typeCodeName, isLocal := getTypeCodeName(typ)
+	globalName := "reflect/types.type:" + typeCodeName
+	var global llvm.Value
+	if isLocal {
+		// This type is a named type inside a function, like this:
+		//
+		//     func foo() any {
+		//         type named int
+		//         return named(0)
+		//     }
+		if obj := c.interfaceTypes.At(typ); obj != nil {
+			global = obj.(llvm.Value)
+		}
+	} else {
+		// Regular type (named or otherwise).
+		global = c.mod.NamedGlobal(globalName)
+	}
 	if global.IsNil() {
-		// Create a new typecode global.
-		global = llvm.AddGlobal(c.mod, c.getLLVMRuntimeType("typecodeID"), globalName)
-		// Some type classes contain more information for underlying types or
-		// element types. Store it directly in the typecode global to make
-		// reflect lowering simpler.
-		var references llvm.Value
-		var length int64
-		var methodSet llvm.Value
-		var ptrTo llvm.Value
-		var typeAssert llvm.Value
+		var typeFields []llvm.Value
+		// Define the type fields. These must match the structs in
+		// src/reflect/type.go (ptrType, arrayType, etc). See the comment at the
+		// top of src/reflect/type.go for more information on the layout of these structs.
+		typeFieldTypes := []*types.Var{
+			types.NewVar(token.NoPos, nil, "kind", types.Typ[types.Int8]),
+		}
 		switch typ := typ.(type) {
+		case *types.Basic:
+			typeFieldTypes = append(typeFieldTypes,
+				types.NewVar(token.NoPos, nil, "ptrTo", types.Typ[types.UnsafePointer]),
+			)
 		case *types.Named:
-			references = c.getTypeCode(typ.Underlying())
+			name := typ.Obj().Name()
+			var pkgname string
+			if pkg := typ.Obj().Pkg(); pkg != nil {
+				pkgname = pkg.Name()
+			}
+			typeFieldTypes = append(typeFieldTypes,
+				types.NewVar(token.NoPos, nil, "numMethods", types.Typ[types.Uint16]),
+				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]),
+				types.NewVar(token.NoPos, nil, "name", types.NewArray(types.Typ[types.Int8], int64(len(pkgname)+1+len(name)+1))),
+			)
 		case *types.Chan:
-			references = c.getTypeCode(typ.Elem())
-		case *types.Pointer:
-			references = c.getTypeCode(typ.Elem())
+			typeFieldTypes = append(typeFieldTypes,
+				types.NewVar(token.NoPos, nil, "numMethods", types.Typ[types.Uint16]), // reuse for select chan direction
+				types.NewVar(token.NoPos, nil, "ptrTo", types.Typ[types.UnsafePointer]),
+				types.NewVar(token.NoPos, nil, "elementType", types.Typ[types.UnsafePointer]),
+			)
 		case *types.Slice:
-			references = c.getTypeCode(typ.Elem())
+			typeFieldTypes = append(typeFieldTypes,
+				types.NewVar(token.NoPos, nil, "numMethods", types.Typ[types.Uint16]),
+				types.NewVar(token.NoPos, nil, "ptrTo", types.Typ[types.UnsafePointer]),
+				types.NewVar(token.NoPos, nil, "elementType", types.Typ[types.UnsafePointer]),
+			)
+		case *types.Pointer:
+			typeFieldTypes = append(typeFieldTypes,
+				types.NewVar(token.NoPos, nil, "numMethods", types.Typ[types.Uint16]),
+				types.NewVar(token.NoPos, nil, "elementType", types.Typ[types.UnsafePointer]),
+			)
 		case *types.Array:
-			references = c.getTypeCode(typ.Elem())
-			length = typ.Len()
+			typeFieldTypes = append(typeFieldTypes,
+				types.NewVar(token.NoPos, nil, "numMethods", types.Typ[types.Uint16]),
+				types.NewVar(token.NoPos, nil, "ptrTo", types.Typ[types.UnsafePointer]),
+				types.NewVar(token.NoPos, nil, "elementType", types.Typ[types.UnsafePointer]),
+				types.NewVar(token.NoPos, nil, "length", types.Typ[types.Uintptr]),
+			)
+		case *types.Map:
+			typeFieldTypes = append(typeFieldTypes,
+				types.NewVar(token.NoPos, nil, "numMethods", types.Typ[types.Uint16]),
+				types.NewVar(token.NoPos, nil, "ptrTo", types.Typ[types.UnsafePointer]),
+				types.NewVar(token.NoPos, nil, "elementType", types.Typ[types.UnsafePointer]),
+				types.NewVar(token.NoPos, nil, "keyType", types.Typ[types.UnsafePointer]),
+			)
 		case *types.Struct:
-			// Take a pointer to the typecodeID of the first field (if it exists).
-			structGlobal := c.makeStructTypeFields(typ)
-			references = llvm.ConstBitCast(structGlobal, global.Type())
+			typeFieldTypes = append(typeFieldTypes,
+				types.NewVar(token.NoPos, nil, "numMethods", types.Typ[types.Uint16]),
+				types.NewVar(token.NoPos, nil, "ptrTo", types.Typ[types.UnsafePointer]),
+				types.NewVar(token.NoPos, nil, "pkgpath", types.Typ[types.UnsafePointer]),
+				types.NewVar(token.NoPos, nil, "numFields", types.Typ[types.Uint16]),
+				types.NewVar(token.NoPos, nil, "fields", types.NewArray(c.getRuntimeType("structField"), int64(typ.NumFields()))),
+			)
 		case *types.Interface:
-			methodSetGlobal := c.getInterfaceMethodSet(typ)
-			references = llvm.ConstBitCast(methodSetGlobal, global.Type())
+			typeFieldTypes = append(typeFieldTypes,
+				types.NewVar(token.NoPos, nil, "ptrTo", types.Typ[types.UnsafePointer]),
+			)
+			// TODO: methods
+		case *types.Signature:
+			typeFieldTypes = append(typeFieldTypes,
+				types.NewVar(token.NoPos, nil, "ptrTo", types.Typ[types.UnsafePointer]),
+			)
+			// TODO: signature params and return values
 		}
-		if _, ok := typ.Underlying().(*types.Interface); !ok {
-			methodSet = c.getTypeMethodSet(typ)
-		} else {
-			typeAssert = c.getInterfaceImplementsFunc(typ)
-			typeAssert = llvm.ConstPtrToInt(typeAssert, c.uintptrType)
+		if hasMethodSet {
+			// This method set is appended at the start of the struct. It is
+			// removed in the interface lowering pass.
+			// TODO: don't remove these and instead do what upstream Go is doing
+			// instead. See: https://research.swtch.com/interfaces. This can
+			// likely be optimized in LLVM using
+			// https://llvm.org/docs/TypeMetadata.html.
+			typeFieldTypes = append([]*types.Var{
+				types.NewVar(token.NoPos, nil, "methodSet", types.Typ[types.UnsafePointer]),
+			}, typeFieldTypes...)
 		}
-		if _, ok := typ.Underlying().(*types.Pointer); !ok {
-			ptrTo = c.getTypeCode(types.NewPointer(typ))
+		globalType := types.NewStruct(typeFieldTypes, nil)
+		global = llvm.AddGlobal(c.mod, c.getLLVMType(globalType), globalName)
+		if isLocal {
+			c.interfaceTypes.Set(typ, global)
 		}
-		globalValue := llvm.ConstNull(global.GlobalValueType())
-		if !references.IsNil() {
-			globalValue = c.builder.CreateInsertValue(globalValue, references, 0, "")
+		metabyte := getTypeKind(typ)
+		switch typ := typ.(type) {
+		case *types.Basic:
+			typeFields = []llvm.Value{c.getTypeCode(types.NewPointer(typ))}
+		case *types.Named:
+			name := typ.Obj().Name()
+			var pkgpath string
+			var pkgname string
+			if pkg := typ.Obj().Pkg(); pkg != nil {
+				pkgpath = pkg.Path()
+				pkgname = pkg.Name()
+			}
+			pkgPathPtr := c.pkgPathPtr(pkgpath)
+			typeFields = []llvm.Value{
+				llvm.ConstInt(c.ctx.Int16Type(), uint64(ms.Len()), false), // numMethods
+				c.getTypeCode(types.NewPointer(typ)),                      // ptrTo
+				c.getTypeCode(typ.Underlying()),                           // underlying
+				pkgPathPtr,                                                // pkgpath pointer
+				c.ctx.ConstString(pkgname+"."+name+"\x00", false),         // name
+			}
+			metabyte |= 1 << 5 // "named" flag
+		case *types.Chan:
+			var dir reflectChanDir
+			switch typ.Dir() {
+			case types.SendRecv:
+				dir = refBothDir
+			case types.RecvOnly:
+				dir = refRecvDir
+			case types.SendOnly:
+				dir = refSendDir
+			}
+
+			typeFields = []llvm.Value{
+				llvm.ConstInt(c.ctx.Int16Type(), uint64(dir), false), // actually channel direction
+				c.getTypeCode(types.NewPointer(typ)),                 // ptrTo
+				c.getTypeCode(typ.Elem()),                            // elementType
+			}
+		case *types.Slice:
+			typeFields = []llvm.Value{
+				llvm.ConstInt(c.ctx.Int16Type(), 0, false), // numMethods
+				c.getTypeCode(types.NewPointer(typ)),       // ptrTo
+				c.getTypeCode(typ.Elem()),                  // elementType
+			}
+		case *types.Pointer:
+			typeFields = []llvm.Value{
+				llvm.ConstInt(c.ctx.Int16Type(), uint64(ms.Len()), false), // numMethods
+				c.getTypeCode(typ.Elem()),
+			}
+		case *types.Array:
+			typeFields = []llvm.Value{
+				llvm.ConstInt(c.ctx.Int16Type(), 0, false),             // numMethods
+				c.getTypeCode(types.NewPointer(typ)),                   // ptrTo
+				c.getTypeCode(typ.Elem()),                              // elementType
+				llvm.ConstInt(c.uintptrType, uint64(typ.Len()), false), // length
+			}
+		case *types.Map:
+			typeFields = []llvm.Value{
+				llvm.ConstInt(c.ctx.Int16Type(), 0, false), // numMethods
+				c.getTypeCode(types.NewPointer(typ)),       // ptrTo
+				c.getTypeCode(typ.Elem()),                  // elem
+				c.getTypeCode(typ.Key()),                   // key
+			}
+		case *types.Struct:
+			var pkgpath string
+			if typ.NumFields() > 0 {
+				if pkg := typ.Field(0).Pkg(); pkg != nil {
+					pkgpath = pkg.Path()
+				}
+			}
+			pkgPathPtr := c.pkgPathPtr(pkgpath)
+
+			typeFields = []llvm.Value{
+				llvm.ConstInt(c.ctx.Int16Type(), uint64(ms.Len()), false), // numMethods
+				c.getTypeCode(types.NewPointer(typ)),                      // ptrTo
+				pkgPathPtr,
+				llvm.ConstInt(c.ctx.Int16Type(), uint64(typ.NumFields()), false), // numFields
+			}
+			structFieldType := c.getLLVMRuntimeType("structField")
+			var fields []llvm.Value
+			for i := 0; i < typ.NumFields(); i++ {
+				field := typ.Field(i)
+				var flags uint8
+				if field.Anonymous() {
+					flags |= structFieldFlagAnonymous
+				}
+				if typ.Tag(i) != "" {
+					flags |= structFieldFlagHasTag
+				}
+				if token.IsExported(field.Name()) {
+					flags |= structFieldFlagIsExported
+				}
+				if field.Embedded() {
+					flags |= structFieldFlagIsEmbedded
+				}
+				data := string(flags) + field.Name() + "\x00"
+				if typ.Tag(i) != "" {
+					if len(typ.Tag(i)) > 0xff {
+						c.addError(field.Pos(), fmt.Sprintf("struct tag is %d bytes which is too long, max is 255", len(typ.Tag(i))))
+					}
+					data += string([]byte{byte(len(typ.Tag(i)))}) + typ.Tag(i)
+				}
+				dataInitializer := c.ctx.ConstString(data, false)
+				dataGlobal := llvm.AddGlobal(c.mod, dataInitializer.Type(), globalName+"."+field.Name())
+				dataGlobal.SetInitializer(dataInitializer)
+				dataGlobal.SetAlignment(1)
+				dataGlobal.SetUnnamedAddr(true)
+				dataGlobal.SetLinkage(llvm.InternalLinkage)
+				dataGlobal.SetGlobalConstant(true)
+				fieldType := c.getTypeCode(field.Type())
+				fields = append(fields, llvm.ConstNamedStruct(structFieldType, []llvm.Value{
+					fieldType,
+					llvm.ConstGEP(dataGlobal.GlobalValueType(), dataGlobal, []llvm.Value{
+						llvm.ConstInt(c.ctx.Int32Type(), 0, false),
+						llvm.ConstInt(c.ctx.Int32Type(), 0, false),
+					}),
+				}))
+			}
+			typeFields = append(typeFields, llvm.ConstArray(structFieldType, fields))
+		case *types.Interface:
+			typeFields = []llvm.Value{c.getTypeCode(types.NewPointer(typ))}
+			// TODO: methods
+		case *types.Signature:
+			typeFields = []llvm.Value{c.getTypeCode(types.NewPointer(typ))}
+			// TODO: params, return values, etc
 		}
-		if length != 0 {
-			lengthValue := llvm.ConstInt(c.uintptrType, uint64(length), false)
-			globalValue = c.builder.CreateInsertValue(globalValue, lengthValue, 1, "")
-		}
-		if !methodSet.IsNil() {
-			globalValue = c.builder.CreateInsertValue(globalValue, methodSet, 2, "")
-		}
-		if !ptrTo.IsNil() {
-			globalValue = c.builder.CreateInsertValue(globalValue, ptrTo, 3, "")
-		}
-		if !typeAssert.IsNil() {
-			globalValue = c.builder.CreateInsertValue(globalValue, typeAssert, 4, "")
+		// Prepend metadata byte.
+		typeFields = append([]llvm.Value{
+			llvm.ConstInt(c.ctx.Int8Type(), uint64(metabyte), false),
+		}, typeFields...)
+		if hasMethodSet {
+			typeFields = append([]llvm.Value{
+				llvm.ConstBitCast(c.getTypeMethodSet(typ), c.i8ptrType),
+			}, typeFields...)
 		}
+		alignment := c.targetData.TypeAllocSize(c.i8ptrType)
+		globalValue := c.ctx.ConstStruct(typeFields, false)
 		global.SetInitializer(globalValue)
-		global.SetLinkage(llvm.LinkOnceODRLinkage)
+		if isLocal {
+			global.SetLinkage(llvm.InternalLinkage)
+		} else {
+			global.SetLinkage(llvm.LinkOnceODRLinkage)
+		}
 		global.SetGlobalConstant(true)
-	}
-	return global
-}
-
-// makeStructTypeFields creates a new global that stores all type information
-// related to this struct type, and returns the resulting global. This global is
-// actually an array of all the fields in the structs.
-func (c *compilerContext) makeStructTypeFields(typ *types.Struct) llvm.Value {
-	// The global is an array of runtime.structField structs.
-	runtimeStructField := c.getLLVMRuntimeType("structField")
-	structGlobalType := llvm.ArrayType(runtimeStructField, typ.NumFields())
-	structGlobal := llvm.AddGlobal(c.mod, structGlobalType, "reflect/types.structFields")
-	structGlobalValue := llvm.ConstNull(structGlobalType)
-	for i := 0; i < typ.NumFields(); i++ {
-		fieldGlobalValue := llvm.ConstNull(runtimeStructField)
-		fieldGlobalValue = c.builder.CreateInsertValue(fieldGlobalValue, c.getTypeCode(typ.Field(i).Type()), 0, "")
-		fieldNameType, fieldName := c.makeGlobalArray([]byte(typ.Field(i).Name()), "reflect/types.structFieldName", c.ctx.Int8Type())
-		fieldName.SetLinkage(llvm.PrivateLinkage)
-		fieldName.SetUnnamedAddr(true)
-		fieldName = llvm.ConstGEP(fieldNameType, fieldName, []llvm.Value{
-			llvm.ConstInt(c.ctx.Int32Type(), 0, false),
-			llvm.ConstInt(c.ctx.Int32Type(), 0, false),
-		})
-		fieldGlobalValue = c.builder.CreateInsertValue(fieldGlobalValue, fieldName, 1, "")
-		if typ.Tag(i) != "" {
-			fieldTagType, fieldTag := c.makeGlobalArray([]byte(typ.Tag(i)), "reflect/types.structFieldTag", c.ctx.Int8Type())
-			fieldTag.SetLinkage(llvm.PrivateLinkage)
-			fieldTag.SetUnnamedAddr(true)
-			fieldTag = llvm.ConstGEP(fieldTagType, fieldTag, []llvm.Value{
-				llvm.ConstInt(c.ctx.Int32Type(), 0, false),
-				llvm.ConstInt(c.ctx.Int32Type(), 0, false),
+		global.SetAlignment(int(alignment))
+		if c.Debug {
+			file := c.getDIFile("<Go type>")
+			diglobal := c.dibuilder.CreateGlobalVariableExpression(file, llvm.DIGlobalVariableExpression{
+				Name:        "type " + typ.String(),
+				File:        file,
+				Line:        1,
+				Type:        c.getDIType(globalType),
+				LocalToUnit: false,
+				Expr:        c.dibuilder.CreateExpression(nil),
+				AlignInBits: uint32(alignment * 8),
 			})
-			fieldGlobalValue = c.builder.CreateInsertValue(fieldGlobalValue, fieldTag, 2, "")
+			global.AddMetadata(0, diglobal)
 		}
-		if typ.Field(i).Embedded() {
-			fieldEmbedded := llvm.ConstInt(c.ctx.Int1Type(), 1, false)
-			fieldGlobalValue = c.builder.CreateInsertValue(fieldGlobalValue, fieldEmbedded, 3, "")
-		}
-		structGlobalValue = c.builder.CreateInsertValue(structGlobalValue, fieldGlobalValue, i, "")
 	}
-	structGlobal.SetInitializer(structGlobalValue)
-	structGlobal.SetUnnamedAddr(true)
-	structGlobal.SetLinkage(llvm.PrivateLinkage)
-	return structGlobal
+	offset := uint64(0)
+	if hasMethodSet {
+		// The pointer to the method set is always the first element of the
+		// global (if there is a method set). However, the pointer we return
+		// should point to the 'kind' field not the method set.
+		offset = 1
+	}
+	return llvm.ConstGEP(global.GlobalValueType(), global, []llvm.Value{
+		llvm.ConstInt(llvm.Int32Type(), 0, false),
+		llvm.ConstInt(llvm.Int32Type(), offset, false),
+	})
 }
 
-var basicTypes = [...]string{
+// getTypeKind returns the type kind for the given type, as defined by
+// reflect.Kind.
+func getTypeKind(t types.Type) uint8 {
+	switch t := t.Underlying().(type) {
+	case *types.Basic:
+		return basicTypes[t.Kind()]
+	case *types.Chan:
+		return typeKindChan
+	case *types.Interface:
+		return typeKindInterface
+	case *types.Pointer:
+		return typeKindPointer
+	case *types.Slice:
+		return typeKindSlice
+	case *types.Array:
+		return typeKindArray
+	case *types.Signature:
+		return typeKindSignature
+	case *types.Map:
+		return typeKindMap
+	case *types.Struct:
+		return typeKindStruct
+	default:
+		panic("unknown type")
+	}
+}
+
+var basicTypeNames = [...]string{
 	types.Bool:          "bool",
 	types.Int:           "int",
 	types.Int8:          "int8",
@@ -176,57 +457,94 @@ var basicTypes = [...]string{
 // getTypeCodeName returns a name for this type that can be used in the
 // interface lowering pass to assign type codes as expected by the reflect
 // package. See getTypeCodeNum.
-func getTypeCodeName(t types.Type) string {
+func getTypeCodeName(t types.Type) (string, bool) {
 	switch t := t.(type) {
 	case *types.Named:
-		return "named:" + t.String()
+		// Note: check for `t.Obj().Pkg() != nil` for Go 1.18 only.
+		if t.Obj().Pkg() != nil && t.Obj().Parent() != t.Obj().Pkg().Scope() {
+			return "named:" + t.String() + "$local", true
+		}
+		return "named:" + t.String(), false
 	case *types.Array:
-		return "array:" + strconv.FormatInt(t.Len(), 10) + ":" + getTypeCodeName(t.Elem())
+		s, isLocal := getTypeCodeName(t.Elem())
+		return "array:" + strconv.FormatInt(t.Len(), 10) + ":" + s, isLocal
 	case *types.Basic:
-		return "basic:" + basicTypes[t.Kind()]
+		return "basic:" + basicTypeNames[t.Kind()], false
 	case *types.Chan:
-		return "chan:" + getTypeCodeName(t.Elem())
+		s, isLocal := getTypeCodeName(t.Elem())
+		var dir string
+		switch t.Dir() {
+		case types.SendOnly:
+			dir = "s:"
+		case types.RecvOnly:
+			dir = "r:"
+		case types.SendRecv:
+			dir = "sr:"
+		}
+
+		return "chan:" + dir + s, isLocal
 	case *types.Interface:
+		isLocal := false
 		methods := make([]string, t.NumMethods())
 		for i := 0; i < t.NumMethods(); i++ {
 			name := t.Method(i).Name()
 			if !token.IsExported(name) {
 				name = t.Method(i).Pkg().Path() + "." + name
 			}
-			methods[i] = name + ":" + getTypeCodeName(t.Method(i).Type())
+			s, local := getTypeCodeName(t.Method(i).Type())
+			if local {
+				isLocal = true
+			}
+			methods[i] = name + ":" + s
 		}
-		return "interface:" + "{" + strings.Join(methods, ",") + "}"
+		return "interface:" + "{" + strings.Join(methods, ",") + "}", isLocal
 	case *types.Map:
-		keyType := getTypeCodeName(t.Key())
-		elemType := getTypeCodeName(t.Elem())
-		return "map:" + "{" + keyType + "," + elemType + "}"
+		keyType, keyLocal := getTypeCodeName(t.Key())
+		elemType, elemLocal := getTypeCodeName(t.Elem())
+		return "map:" + "{" + keyType + "," + elemType + "}", keyLocal || elemLocal
 	case *types.Pointer:
-		return "pointer:" + getTypeCodeName(t.Elem())
+		s, isLocal := getTypeCodeName(t.Elem())
+		return "pointer:" + s, isLocal
 	case *types.Signature:
+		isLocal := false
 		params := make([]string, t.Params().Len())
 		for i := 0; i < t.Params().Len(); i++ {
-			params[i] = getTypeCodeName(t.Params().At(i).Type())
+			s, local := getTypeCodeName(t.Params().At(i).Type())
+			if local {
+				isLocal = true
+			}
+			params[i] = s
 		}
 		results := make([]string, t.Results().Len())
 		for i := 0; i < t.Results().Len(); i++ {
-			results[i] = getTypeCodeName(t.Results().At(i).Type())
+			s, local := getTypeCodeName(t.Results().At(i).Type())
+			if local {
+				isLocal = true
+			}
+			results[i] = s
 		}
-		return "func:" + "{" + strings.Join(params, ",") + "}{" + strings.Join(results, ",") + "}"
+		return "func:" + "{" + strings.Join(params, ",") + "}{" + strings.Join(results, ",") + "}", isLocal
 	case *types.Slice:
-		return "slice:" + getTypeCodeName(t.Elem())
+		s, isLocal := getTypeCodeName(t.Elem())
+		return "slice:" + s, isLocal
 	case *types.Struct:
 		elems := make([]string, t.NumFields())
+		isLocal := false
 		for i := 0; i < t.NumFields(); i++ {
 			embedded := ""
 			if t.Field(i).Embedded() {
 				embedded = "#"
 			}
-			elems[i] = embedded + t.Field(i).Name() + ":" + getTypeCodeName(t.Field(i).Type())
+			s, local := getTypeCodeName(t.Field(i).Type())
+			if local {
+				isLocal = true
+			}
+			elems[i] = embedded + t.Field(i).Name() + ":" + s
 			if t.Tag(i) != "" {
 				elems[i] += "`" + t.Tag(i) + "`"
 			}
 		}
-		return "struct:" + "{" + strings.Join(elems, ",") + "}"
+		return "struct:" + "{" + strings.Join(elems, ",") + "}", isLocal
 	default:
 		panic("unknown type: " + t.String())
 	}
@@ -235,75 +553,40 @@ func getTypeCodeName(t types.Type) string {
 // getTypeMethodSet returns a reference (GEP) to a global method set. This
 // method set should be unreferenced after the interface lowering pass.
 func (c *compilerContext) getTypeMethodSet(typ types.Type) llvm.Value {
-	global := c.mod.NamedGlobal(typ.String() + "$methodset")
-	zero := llvm.ConstInt(c.ctx.Int32Type(), 0, false)
-	if !global.IsNil() {
-		// the method set already exists
-		return llvm.ConstGEP(global.GlobalValueType(), global, []llvm.Value{zero, zero})
-	}
+	globalName := typ.String() + "$methodset"
+	global := c.mod.NamedGlobal(globalName)
+	if global.IsNil() {
+		ms := c.program.MethodSets.MethodSet(typ)
 
-	ms := c.program.MethodSets.MethodSet(typ)
-	if ms.Len() == 0 {
-		// no methods, so can leave that one out
-		return llvm.ConstPointerNull(llvm.PointerType(c.getLLVMRuntimeType("interfaceMethodInfo"), 0))
-	}
-
-	methods := make([]llvm.Value, ms.Len())
-	interfaceMethodInfoType := c.getLLVMRuntimeType("interfaceMethodInfo")
-	for i := 0; i < ms.Len(); i++ {
-		method := ms.At(i)
-		signatureGlobal := c.getMethodSignature(method.Obj().(*types.Func))
-		fn := c.program.MethodValue(method)
-		llvmFnType, llvmFn := c.getFunction(fn)
-		if llvmFn.IsNil() {
-			// compiler error, so panic
-			panic("cannot find function: " + c.getFunctionInfo(fn).linkName)
+		// Create method set.
+		var signatures, wrappers []llvm.Value
+		for i := 0; i < ms.Len(); i++ {
+			method := ms.At(i)
+			signatureGlobal := c.getMethodSignature(method.Obj().(*types.Func))
+			signatures = append(signatures, signatureGlobal)
+			fn := c.program.MethodValue(method)
+			llvmFnType, llvmFn := c.getFunction(fn)
+			if llvmFn.IsNil() {
+				// compiler error, so panic
+				panic("cannot find function: " + c.getFunctionInfo(fn).linkName)
+			}
+			wrapper := c.getInterfaceInvokeWrapper(fn, llvmFnType, llvmFn)
+			wrappers = append(wrappers, wrapper)
 		}
-		wrapper := c.getInterfaceInvokeWrapper(fn, llvmFnType, llvmFn)
-		methodInfo := llvm.ConstNamedStruct(interfaceMethodInfoType, []llvm.Value{
-			signatureGlobal,
-			llvm.ConstPtrToInt(wrapper, c.uintptrType),
-		})
-		methods[i] = methodInfo
-	}
-	arrayType := llvm.ArrayType(interfaceMethodInfoType, len(methods))
-	value := llvm.ConstArray(interfaceMethodInfoType, methods)
-	global = llvm.AddGlobal(c.mod, arrayType, typ.String()+"$methodset")
-	global.SetInitializer(value)
-	global.SetGlobalConstant(true)
-	global.SetLinkage(llvm.LinkOnceODRLinkage)
-	return llvm.ConstGEP(arrayType, global, []llvm.Value{zero, zero})
-}
 
-// getInterfaceMethodSet returns a global variable with the method set of the
-// given named interface type. This method set is used by the interface lowering
-// pass.
-func (c *compilerContext) getInterfaceMethodSet(typ types.Type) llvm.Value {
-	name := typ.String()
-	if _, ok := typ.(*types.Named); !ok {
-		// Anonymous interface.
-		name = "reflect/types.interface:" + name
+		// Construct global value.
+		globalValue := c.ctx.ConstStruct([]llvm.Value{
+			llvm.ConstInt(c.uintptrType, uint64(ms.Len()), false),
+			llvm.ConstArray(c.i8ptrType, signatures),
+			c.ctx.ConstStruct(wrappers, false),
+		}, false)
+		global = llvm.AddGlobal(c.mod, globalValue.Type(), globalName)
+		global.SetInitializer(globalValue)
+		global.SetGlobalConstant(true)
+		global.SetUnnamedAddr(true)
+		global.SetLinkage(llvm.LinkOnceODRLinkage)
 	}
-	global := c.mod.NamedGlobal(name + "$interface")
-	zero := llvm.ConstInt(c.ctx.Int32Type(), 0, false)
-	if !global.IsNil() {
-		// method set already exist, return it
-		return llvm.ConstGEP(global.GlobalValueType(), global, []llvm.Value{zero, zero})
-	}
-
-	// Every method is a *i8 reference indicating the signature of this method.
-	methods := make([]llvm.Value, typ.Underlying().(*types.Interface).NumMethods())
-	for i := range methods {
-		method := typ.Underlying().(*types.Interface).Method(i)
-		methods[i] = c.getMethodSignature(method)
-	}
-
-	value := llvm.ConstArray(c.i8ptrType, methods)
-	global = llvm.AddGlobal(c.mod, value.Type(), name+"$interface")
-	global.SetInitializer(value)
-	global.SetGlobalConstant(true)
-	global.SetLinkage(llvm.LinkOnceODRLinkage)
-	return llvm.ConstGEP(value.Type(), global, []llvm.Value{zero, zero})
+	return global
 }
 
 // getMethodSignatureName returns a unique name (that can be used as the name of
@@ -345,7 +628,7 @@ func (c *compilerContext) getMethodSignature(method *types.Func) llvm.Value {
 // Type asserts on concrete types are trivial: just compare type numbers. Type
 // asserts on interfaces are more difficult, see the comments in the function.
 func (b *builder) createTypeAssert(expr *ssa.TypeAssert) llvm.Value {
-	itf := b.getValue(expr.X)
+	itf := b.getValue(expr.X, getPos(expr))
 	assertedType := b.getLLVMType(expr.AssertedType)
 
 	actualTypeNum := b.CreateExtractValue(itf, 0, "interface.type")
@@ -364,7 +647,11 @@ func (b *builder) createTypeAssert(expr *ssa.TypeAssert) llvm.Value {
 		commaOk = b.CreateCall(fn.GlobalValueType(), fn, []llvm.Value{actualTypeNum}, "")
 
 	} else {
-		globalName := "reflect/types.typeid:" + getTypeCodeName(expr.AssertedType)
+		assertedTypeGlobal := b.getTypeCode(expr.AssertedType)
+		if !assertedTypeGlobal.IsAConstantExpr().IsNil() {
+			assertedTypeGlobal = assertedTypeGlobal.Operand(0) // resolve the GEP operation
+		}
+		globalName := "reflect/types.typeid:" + strings.TrimPrefix(assertedTypeGlobal.Name(), "reflect/types.type:")
 		assertedTypeCodeGlobal := b.mod.NamedGlobal(globalName)
 		if assertedTypeCodeGlobal.IsNil() {
 			// Create a new typecode global.
@@ -440,10 +727,11 @@ func (c *compilerContext) getMethodsString(itf *types.Interface) string {
 // getInterfaceImplementsfunc returns a declared function that works as a type
 // switch. The interface lowering pass will define this function.
 func (c *compilerContext) getInterfaceImplementsFunc(assertedType types.Type) llvm.Value {
-	fnName := getTypeCodeName(assertedType.Underlying()) + ".$typeassert"
+	s, _ := getTypeCodeName(assertedType.Underlying())
+	fnName := s + ".$typeassert"
 	llvmFn := c.mod.NamedFunction(fnName)
 	if llvmFn.IsNil() {
-		llvmFnType := llvm.FunctionType(c.ctx.Int1Type(), []llvm.Type{c.uintptrType}, false)
+		llvmFnType := llvm.FunctionType(c.ctx.Int1Type(), []llvm.Type{c.i8ptrType}, false)
 		llvmFn = llvm.AddFunction(c.mod, fnName, llvmFnType)
 		c.addStandardDeclaredAttributes(llvmFn)
 		methods := c.getMethodsString(assertedType.Underlying().(*types.Interface))
@@ -456,7 +744,8 @@ func (c *compilerContext) getInterfaceImplementsFunc(assertedType types.Type) ll
 // thunk is declared, not defined: it will be defined by the interface lowering
 // pass.
 func (c *compilerContext) getInvokeFunction(instr *ssa.CallCommon) llvm.Value {
-	fnName := getTypeCodeName(instr.Value.Type().Underlying()) + "." + instr.Method.Name() + "$invoke"
+	s, _ := getTypeCodeName(instr.Value.Type().Underlying())
+	fnName := s + "." + instr.Method.Name() + "$invoke"
 	llvmFn := c.mod.NamedFunction(fnName)
 	if llvmFn.IsNil() {
 		sig := instr.Method.Type().(*types.Signature)
@@ -464,7 +753,7 @@ func (c *compilerContext) getInvokeFunction(instr *ssa.CallCommon) llvm.Value {
 		for i := 0; i < sig.Params().Len(); i++ {
 			paramTuple = append(paramTuple, sig.Params().At(i))
 		}
-		paramTuple = append(paramTuple, types.NewVar(token.NoPos, nil, "$typecode", types.Typ[types.Uintptr]))
+		paramTuple = append(paramTuple, types.NewVar(token.NoPos, nil, "$typecode", types.Typ[types.UnsafePointer]))
 		llvmFnType := c.getRawFuncType(types.NewSignature(sig.Recv(), types.NewTuple(paramTuple...), sig.Results(), false))
 		llvmFn = llvm.AddFunction(c.mod, fnName, llvmFnType)
 		c.addStandardDeclaredAttributes(llvmFn)
@@ -601,7 +890,7 @@ func typestring(t types.Type) string {
 	case *types.Array:
 		return "[" + strconv.FormatInt(t.Len(), 10) + "]" + typestring(t.Elem())
 	case *types.Basic:
-		return basicTypes[t.Kind()]
+		return basicTypeNames[t.Kind()]
 	case *types.Chan:
 		switch t.Dir() {
 		case types.SendRecv:

compiler/interrupt.go

@@ -24,7 +24,7 @@ func (b *builder) createInterruptGlobal(instr *ssa.CallCommon) (llvm.Value, erro
 	// Note that bound functions are allowed if the function has a pointer
 	// receiver and is a global. This is rather strict but still allows for
 	// idiomatic Go code.
-	funcValue := b.getValue(instr.Args[1])
+	funcValue := b.getValue(instr.Args[1], getPos(instr))
 	if funcValue.IsAConstant().IsNil() {
 		// Try to determine the cause of the non-constantness for a nice error
 		// message.

compiler/intrinsics.go

@@ -24,6 +24,8 @@ func (b *builder) defineIntrinsicFunction() {
 		b.createMemoryCopyImpl()
 	case name == "runtime.memzero":
 		b.createMemoryZeroImpl()
+	case name == "runtime.KeepAlive":
+		b.createKeepAliveImpl()
 	case strings.HasPrefix(name, "runtime/volatile.Load"):
 		b.createVolatileLoad()
 	case strings.HasPrefix(name, "runtime/volatile.Store"):
@@ -56,7 +58,7 @@ func (b *builder) createMemoryCopyImpl() {
 	}
 	var params []llvm.Value
 	for _, param := range b.fn.Params {
-		params = append(params, b.getValue(param))
+		params = append(params, b.getValue(param, getPos(b.fn)))
 	}
 	params = append(params, llvm.ConstInt(b.ctx.Int1Type(), 0, false))
 	b.CreateCall(llvmFn.GlobalValueType(), llvmFn, params, "")
@@ -78,15 +80,38 @@ func (b *builder) createMemoryZeroImpl() {
 		llvmFn = llvm.AddFunction(b.mod, fnName, fnType)
 	}
 	params := []llvm.Value{
-		b.getValue(b.fn.Params[0]),
+		b.getValue(b.fn.Params[0], getPos(b.fn)),
 		llvm.ConstInt(b.ctx.Int8Type(), 0, false),
-		b.getValue(b.fn.Params[1]),
+		b.getValue(b.fn.Params[1], getPos(b.fn)),
 		llvm.ConstInt(b.ctx.Int1Type(), 0, false),
 	}
 	b.CreateCall(llvmFn.GlobalValueType(), llvmFn, params, "")
 	b.CreateRetVoid()
 }
 
+// createKeepAlive creates the runtime.KeepAlive function. It is implemented
+// using inline assembly.
+func (b *builder) createKeepAliveImpl() {
+	b.createFunctionStart(true)
+
+	// Get the underlying value of the interface value.
+	interfaceValue := b.getValue(b.fn.Params[0], getPos(b.fn))
+	pointerValue := b.CreateExtractValue(interfaceValue, 1, "")
+
+	// Create an equivalent of the following C code, which is basically just a
+	// nop but ensures the pointerValue is kept alive:
+	//
+	//     __asm__ __volatile__("" : : "r"(pointerValue))
+	//
+	// It should be portable to basically everything as the "r" register type
+	// exists basically everywhere.
+	asmType := llvm.FunctionType(b.ctx.VoidType(), []llvm.Type{b.i8ptrType}, false)
+	asmFn := llvm.InlineAsm(asmType, "", "r", true, false, 0, false)
+	b.createCall(asmType, asmFn, []llvm.Value{pointerValue}, "")
+
+	b.CreateRetVoid()
+}
+
 var mathToLLVMMapping = map[string]string{
 	"math.Ceil":  "llvm.ceil.f64",
 	"math.Exp":   "llvm.exp.f64",
@@ -124,8 +149,123 @@ func (b *builder) defineMathOp() {
 	// Create a call to the intrinsic.
 	args := make([]llvm.Value, len(b.fn.Params))
 	for i, param := range b.fn.Params {
-		args[i] = b.getValue(param)
+		args[i] = b.getValue(param, getPos(b.fn))
 	}
 	result := b.CreateCall(llvmFn.GlobalValueType(), llvmFn, args, "")
 	b.CreateRet(result)
 }
+
+// Implement most math/bits functions.
+//
+// This implements all the functions that operate on bits. It does not yet
+// implement the arithmetic functions (like bits.Add), which also have LLVM
+// intrinsics.
+func (b *builder) defineMathBitsIntrinsic() bool {
+	if b.fn.Pkg.Pkg.Path() != "math/bits" {
+		return false
+	}
+	name := b.fn.Name()
+	switch name {
+	case "LeadingZeros", "LeadingZeros8", "LeadingZeros16", "LeadingZeros32", "LeadingZeros64",
+		"TrailingZeros", "TrailingZeros8", "TrailingZeros16", "TrailingZeros32", "TrailingZeros64":
+		b.createFunctionStart(true)
+		param := b.getValue(b.fn.Params[0], b.fn.Pos())
+		valueType := param.Type()
+		var intrinsicName string
+		if strings.HasPrefix(name, "Leading") { // LeadingZeros
+			intrinsicName = "llvm.ctlz.i" + strconv.Itoa(valueType.IntTypeWidth())
+		} else { // TrailingZeros
+			intrinsicName = "llvm.cttz.i" + strconv.Itoa(valueType.IntTypeWidth())
+		}
+		llvmFn := b.mod.NamedFunction(intrinsicName)
+		llvmFnType := llvm.FunctionType(valueType, []llvm.Type{valueType, b.ctx.Int1Type()}, false)
+		if llvmFn.IsNil() {
+			llvmFn = llvm.AddFunction(b.mod, intrinsicName, llvmFnType)
+		}
+		result := b.createCall(llvmFnType, llvmFn, []llvm.Value{
+			param,
+			llvm.ConstInt(b.ctx.Int1Type(), 0, false),
+		}, "")
+		result = b.createZExtOrTrunc(result, b.intType)
+		b.CreateRet(result)
+		return true
+	case "Len", "Len8", "Len16", "Len32", "Len64":
+		// bits.Len can be implemented as:
+		//     (unsafe.Sizeof(v) * 8) -  bits.LeadingZeros(n)
+		// Not sure why this isn't already done in the standard library, as it
+		// is much simpler than a lookup table.
+		b.createFunctionStart(true)
+		param := b.getValue(b.fn.Params[0], b.fn.Pos())
+		valueType := param.Type()
+		valueBits := valueType.IntTypeWidth()
+		intrinsicName := "llvm.ctlz.i" + strconv.Itoa(valueBits)
+		llvmFn := b.mod.NamedFunction(intrinsicName)
+		llvmFnType := llvm.FunctionType(valueType, []llvm.Type{valueType, b.ctx.Int1Type()}, false)
+		if llvmFn.IsNil() {
+			llvmFn = llvm.AddFunction(b.mod, intrinsicName, llvmFnType)
+		}
+		result := b.createCall(llvmFnType, llvmFn, []llvm.Value{
+			param,
+			llvm.ConstInt(b.ctx.Int1Type(), 0, false),
+		}, "")
+		result = b.createZExtOrTrunc(result, b.intType)
+		maxLen := llvm.ConstInt(b.intType, uint64(valueBits), false) // number of bits in the value
+		result = b.CreateSub(maxLen, result, "")
+		b.CreateRet(result)
+		return true
+	case "OnesCount", "OnesCount8", "OnesCount16", "OnesCount32", "OnesCount64":
+		b.createFunctionStart(true)
+		param := b.getValue(b.fn.Params[0], b.fn.Pos())
+		valueType := param.Type()
+		intrinsicName := "llvm.ctpop.i" + strconv.Itoa(valueType.IntTypeWidth())
+		llvmFn := b.mod.NamedFunction(intrinsicName)
+		llvmFnType := llvm.FunctionType(valueType, []llvm.Type{valueType}, false)
+		if llvmFn.IsNil() {
+			llvmFn = llvm.AddFunction(b.mod, intrinsicName, llvmFnType)
+		}
+		result := b.createCall(llvmFnType, llvmFn, []llvm.Value{param}, "")
+		result = b.createZExtOrTrunc(result, b.intType)
+		b.CreateRet(result)
+		return true
+	case "Reverse", "Reverse8", "Reverse16", "Reverse32", "Reverse64",
+		"ReverseBytes", "ReverseBytes16", "ReverseBytes32", "ReverseBytes64":
+		b.createFunctionStart(true)
+		param := b.getValue(b.fn.Params[0], b.fn.Pos())
+		valueType := param.Type()
+		var intrinsicName string
+		if strings.HasPrefix(name, "ReverseBytes") {
+			intrinsicName = "llvm.bswap.i" + strconv.Itoa(valueType.IntTypeWidth())
+		} else { // Reverse
+			intrinsicName = "llvm.bitreverse.i" + strconv.Itoa(valueType.IntTypeWidth())
+		}
+		llvmFn := b.mod.NamedFunction(intrinsicName)
+		llvmFnType := llvm.FunctionType(valueType, []llvm.Type{valueType}, false)
+		if llvmFn.IsNil() {
+			llvmFn = llvm.AddFunction(b.mod, intrinsicName, llvmFnType)
+		}
+		result := b.createCall(llvmFnType, llvmFn, []llvm.Value{param}, "")
+		b.CreateRet(result)
+		return true
+	case "RotateLeft", "RotateLeft8", "RotateLeft16", "RotateLeft32", "RotateLeft64":
+		// Warning: the documentation says these functions must be constant time.
+		// I do not think LLVM guarantees this, but there's a good chance LLVM
+		// already recognized the rotate instruction so it probably won't get
+		// any _worse_ by implementing these rotate functions.
+		b.createFunctionStart(true)
+		x := b.getValue(b.fn.Params[0], b.fn.Pos())
+		k := b.getValue(b.fn.Params[1], b.fn.Pos())
+		valueType := x.Type()
+		intrinsicName := "llvm.fshl.i" + strconv.Itoa(valueType.IntTypeWidth())
+		llvmFn := b.mod.NamedFunction(intrinsicName)
+		llvmFnType := llvm.FunctionType(valueType, []llvm.Type{valueType, valueType, valueType}, false)
+		if llvmFn.IsNil() {
+			llvmFn = llvm.AddFunction(b.mod, intrinsicName, llvmFnType)
+		}
+		k = b.createZExtOrTrunc(k, valueType)
+		result := b.createCall(llvmFnType, llvmFn, []llvm.Value{x, x, k}, "")
+		b.CreateRet(result)
+		return true
+	default:
+		return false
+	}
+}

compiler/llvm.go

@@ -464,6 +464,19 @@ func (b *builder) readStackPointer() llvm.Value {
 	return b.CreateCall(stacksave.GlobalValueType(), stacksave, nil, "")
 }
 
+// createZExtOrTrunc lets the input value fit in the output type bits, by zero
+// extending or truncating the integer.
+func (b *builder) createZExtOrTrunc(value llvm.Value, t llvm.Type) llvm.Value {
+	valueBits := value.Type().IntTypeWidth()
+	resultBits := t.IntTypeWidth()
+	if valueBits > resultBits {
+		value = b.CreateTrunc(value, t, "")
+	} else if valueBits < resultBits {
+		value = b.CreateZExt(value, t, "")
+	}
+	return value
+}
+
 // Reverse a slice of bytes. From the wiki:
 // https://github.com/golang/go/wiki/SliceTricks#reversing
 func reverseBytes(buf []byte) {

compiler/map.go

@@ -46,7 +46,7 @@ func (b *builder) createMakeMap(expr *ssa.MakeMap) (llvm.Value, error) {
 	sizeHint := llvm.ConstInt(b.uintptrType, 8, false)
 	algEnum := llvm.ConstInt(b.ctx.Int8Type(), alg, false)
 	if expr.Reserve != nil {
-		sizeHint = b.getValue(expr.Reserve)
+		sizeHint = b.getValue(expr.Reserve, getPos(expr))
 		var err error
 		sizeHint, err = b.createConvert(expr.Reserve.Type(), types.Typ[types.Uintptr], sizeHint, expr.Pos())
 		if err != nil {
@@ -78,6 +78,7 @@ 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
@@ -89,6 +90,7 @@ func (b *builder) createMapLookup(keyType, valueType types.Type, m, key llvm.Val
 		// growth.
 		mapKeyAlloca, mapKeyPtr, 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, mapKeyPtr, mapValuePtr, mapValueSize}
 		commaOkValue = b.createRuntimeCall("hashmapBinaryGet", params, "")
@@ -98,7 +100,7 @@ func (b *builder) createMapLookup(keyType, valueType types.Type, m, key llvm.Val
 		itfKey := key
 		if _, ok := keyType.(*types.Interface); !ok {
 			// Not already an interface, so convert it to an interface now.
-			itfKey = b.createMakeInterface(key, keyType, pos)
+			itfKey = b.createMakeInterface(key, origKeyType, pos)
 		}
 		params := []llvm.Value{m, itfKey, mapValuePtr, mapValueSize}
 		commaOkValue = b.createRuntimeCall("hashmapInterfaceGet", params, "")
@@ -124,6 +126,7 @@ 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, valuePtr, 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
@@ -133,6 +136,7 @@ func (b *builder) createMapUpdate(keyType types.Type, m, key, value llvm.Value,
 		// key can be compared with runtime.memequal
 		keyAlloca, keyPtr, keySize := b.createTemporaryAlloca(key.Type(), "hashmap.key")
 		b.CreateStore(key, keyAlloca)
+		b.zeroUndefBytes(b.getLLVMType(keyType), keyAlloca)
 		params := []llvm.Value{m, keyPtr, valuePtr}
 		b.createRuntimeCall("hashmapBinarySet", params, "")
 		b.emitLifetimeEnd(keyPtr, keySize)
@@ -141,7 +145,7 @@ func (b *builder) createMapUpdate(keyType types.Type, m, key, value llvm.Value,
 		itfKey := key
 		if _, ok := keyType.(*types.Interface); !ok {
 			// Not already an interface, so convert it to an interface first.
-			itfKey = b.createMakeInterface(key, keyType, pos)
+			itfKey = b.createMakeInterface(key, origKeyType, pos)
 		}
 		params := []llvm.Value{m, itfKey, valuePtr}
 		b.createRuntimeCall("hashmapInterfaceSet", params, "")
@@ -152,6 +156,7 @@ 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
@@ -161,6 +166,7 @@ func (b *builder) createMapDelete(keyType types.Type, m, key llvm.Value, pos tok
 	} else if hashmapIsBinaryKey(keyType) {
 		keyAlloca, keyPtr, keySize := b.createTemporaryAlloca(key.Type(), "hashmap.key")
 		b.CreateStore(key, keyAlloca)
+		b.zeroUndefBytes(b.getLLVMType(keyType), keyAlloca)
 		params := []llvm.Value{m, keyPtr}
 		b.createRuntimeCall("hashmapBinaryDelete", params, "")
 		b.emitLifetimeEnd(keyPtr, keySize)
@@ -171,7 +177,7 @@ func (b *builder) createMapDelete(keyType types.Type, m, key llvm.Value, pos tok
 		itfKey := key
 		if _, ok := keyType.(*types.Interface); !ok {
 			// Not already an interface, so convert it to an interface first.
-			itfKey = b.createMakeInterface(key, keyType, pos)
+			itfKey = b.createMakeInterface(key, origKeyType, pos)
 		}
 		params := []llvm.Value{m, itfKey}
 		b.createRuntimeCall("hashmapInterfaceDelete", params, "")
@@ -240,7 +246,8 @@ func (b *builder) createMapIteratorNext(rangeVal ssa.Value, llvmRangeVal, it llv
 }
 
 // Returns true if this key type does not contain strings, interfaces etc., so
-// can be compared with runtime.memequal.
+// can be compared with runtime.memequal.  Note that padding bytes are undef
+// and can alter two "equal" structs being equal when compared with memequal.
 func hashmapIsBinaryKey(keyType types.Type) bool {
 	switch keyType := keyType.(type) {
 	case *types.Basic:
@@ -263,3 +270,76 @@ func hashmapIsBinaryKey(keyType types.Type) bool {
 		return false
 	}
 }
+
+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.
+
+	zero := llvm.ConstInt(b.ctx.Int32Type(), 0, 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()
+
+		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)
+		}
+
+	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 allcoate struct.
+				nextOffset = b.targetData.TypeAllocSize(llvmStructType)
+			}
+
+			if fieldEndOffset != nextOffset {
+				n := llvm.ConstInt(b.uintptrType, nextOffset-fieldEndOffset, false)
+				llvmStoreSize := llvm.ConstInt(b.uintptrType, storeSize, false)
+				gepPtr := elemPtr
+				if gepPtr.Type() != b.i8ptrType {
+					gepPtr = b.CreateBitCast(gepPtr, b.i8ptrType, "") // LLVM 14
+				}
+				paddingStart := b.CreateInBoundsGEP(b.ctx.Int8Type(), gepPtr, []llvm.Value{llvmStoreSize}, "")
+				if paddingStart.Type() != b.i8ptrType {
+					paddingStart = b.CreateBitCast(paddingStart, b.i8ptrType, "") // LLVM 14
+				}
+				b.createRuntimeCall("memzero", []llvm.Value{paddingStart, n}, "")
+			}
+		}
+	}
+
+	return nil
+}

compiler/symbol.go

@@ -52,6 +52,17 @@ const (
 	inlineNone
 )
 
+// Values for the allockind attribute. Source:
+// https://github.com/llvm/llvm-project/blob/release/16.x/llvm/include/llvm/IR/Attributes.h#L49
+const (
+	allocKindAlloc = 1 << iota
+	allocKindRealloc
+	allocKindFree
+	allocKindUninitialized
+	allocKindZeroed
+	allocKindAligned
+)
+
 // getFunction returns the LLVM function for the given *ssa.Function, creating
 // it if needed. It can later be filled with compilerContext.createFunction().
 func (c *compilerContext) getFunction(fn *ssa.Function) (llvm.Type, llvm.Value) {
@@ -133,6 +144,20 @@ func (c *compilerContext) getFunction(fn *ssa.Function) (llvm.Type, llvm.Value)
 		for _, attrName := range []string{"noalias", "nonnull"} {
 			llvmFn.AddAttributeAtIndex(0, c.ctx.CreateEnumAttribute(llvm.AttributeKindID(attrName), 0))
 		}
+		if llvmutil.Major() >= 15 { // allockind etc are not available in LLVM 14
+			// Add attributes to signal to LLVM that this is an allocator
+			// function. This enables a number of optimizations.
+			llvmFn.AddFunctionAttr(c.ctx.CreateEnumAttribute(llvm.AttributeKindID("allockind"), allocKindAlloc|allocKindZeroed))
+			llvmFn.AddFunctionAttr(c.ctx.CreateStringAttribute("alloc-family", "runtime.alloc"))
+			// Use a special value to indicate the first parameter:
+			// > allocsize has two integer arguments, but because they're both 32 bits, we can
+			// > pack them into one 64-bit value, at the cost of making said value
+			// > nonsensical.
+			// >
+			// > In order to do this, we need to reserve one value of the second (optional)
+			// > allocsize argument to signify "not present."
+			llvmFn.AddFunctionAttr(c.ctx.CreateEnumAttribute(llvm.AttributeKindID("allocsize"), 0x0000_0000_ffff_ffff))
+		}
 	case "runtime.sliceAppend":
 		// Appending a slice will only read the to-be-appended slice, it won't
 		// be modified.
@@ -263,6 +288,15 @@ func (info *functionInfo) parsePragmas(f *ssa.Function) {
 					continue
 				}
 				info.module = parts[1]
+			case "//go:wasmimport":
+				// Import a WebAssembly function, for example a WASI function.
+				// For details, see: https://github.com/golang/go/issues/38248
+				if len(parts) != 3 || len(f.Blocks) != 0 {
+					continue
+				}
+				info.exported = true
+				info.module = parts[1]
+				info.importName = parts[2]
 			case "//go:inline":
 				info.inline = inlineHint
 			case "//go:noinline":
@@ -279,8 +313,12 @@ func (info *functionInfo) parsePragmas(f *ssa.Function) {
 					info.linkName = parts[2]
 				}
 			case "//go:section":
+				// Only enable go:section when the package imports "unsafe".
+				// go:section also implies go:noinline since inlining could
+				// move the code to a different section than that requested.
 				if len(parts) == 2 && hasUnsafeImport(f.Pkg.Pkg) {
 					info.section = parts[1]
+					info.inline = inlineNone
 				}
 			case "//go:nobounds":
 				// Skip bounds checking in this function. Useful for some
@@ -433,7 +471,6 @@ func (c *compilerContext) getGlobal(g *ssa.Global) llvm.Value {
 		llvmGlobal = llvm.AddGlobal(c.mod, llvmType, info.linkName)
 
 		// Set alignment from the //go:align comment.
-		var alignInBits uint32
 		alignment := c.targetData.ABITypeAlignment(llvmType)
 		if info.align > alignment {
 			alignment = info.align
@@ -444,7 +481,6 @@ func (c *compilerContext) getGlobal(g *ssa.Global) llvm.Value {
 			c.addError(g.Pos(), "global variable alignment must be a positive power of two")
 		} else {
 			// Set the alignment only when it is a power of two.
-			alignInBits = uint32(alignment) ^ uint32(alignment-1)
 			llvmGlobal.SetAlignment(alignment)
 		}
 
@@ -459,7 +495,7 @@ func (c *compilerContext) getGlobal(g *ssa.Global) llvm.Value {
 				Type:        c.getDIType(typ),
 				LocalToUnit: false,
 				Expr:        c.dibuilder.CreateExpression(nil),
-				AlignInBits: alignInBits,
+				AlignInBits: uint32(alignment) * 8,
 			})
 			llvmGlobal.AddMetadata(0, diglobal)
 		}

compiler/syscall.go

@@ -14,7 +14,7 @@ import (
 // and returns the result as a single integer (the system call result). The
 // result is not further interpreted.
 func (b *builder) createRawSyscall(call *ssa.CallCommon) (llvm.Value, error) {
-	num := b.getValue(call.Args[0])
+	num := b.getValue(call.Args[0], getPos(call))
 	switch {
 	case b.GOARCH == "amd64" && b.GOOS == "linux":
 		// Sources:
@@ -37,7 +37,7 @@ func (b *builder) createRawSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 				"{r12}",
 				"{r13}",
 			}[i]
-			llvmValue := b.getValue(arg)
+			llvmValue := b.getValue(arg, getPos(call))
 			args = append(args, llvmValue)
 			argTypes = append(argTypes, llvmValue.Type())
 		}
@@ -64,7 +64,7 @@ func (b *builder) createRawSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 				"{edi}",
 				"{ebp}",
 			}[i]
-			llvmValue := b.getValue(arg)
+			llvmValue := b.getValue(arg, getPos(call))
 			args = append(args, llvmValue)
 			argTypes = append(argTypes, llvmValue.Type())
 		}
@@ -89,7 +89,7 @@ func (b *builder) createRawSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 				"{r5}",
 				"{r6}",
 			}[i]
-			llvmValue := b.getValue(arg)
+			llvmValue := b.getValue(arg, getPos(call))
 			args = append(args, llvmValue)
 			argTypes = append(argTypes, llvmValue.Type())
 		}
@@ -119,7 +119,7 @@ func (b *builder) createRawSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 				"{x4}",
 				"{x5}",
 			}[i]
-			llvmValue := b.getValue(arg)
+			llvmValue := b.getValue(arg, getPos(call))
 			args = append(args, llvmValue)
 			argTypes = append(argTypes, llvmValue.Type())
 		}
@@ -177,12 +177,12 @@ func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		var paramTypes []llvm.Type
 		var params []llvm.Value
 		for _, val := range call.Args[2:] {
-			param := b.getValue(val)
+			param := b.getValue(val, getPos(call))
 			params = append(params, param)
 			paramTypes = append(paramTypes, param.Type())
 		}
 		llvmType := llvm.FunctionType(b.uintptrType, paramTypes, false)
-		fn := b.getValue(call.Args[0])
+		fn := b.getValue(call.Args[0], getPos(call))
 		fnPtr := b.CreateIntToPtr(fn, llvm.PointerType(llvmType, 0), "")
 
 		// Prepare some functions that will be called later.

compiler/testdata/basic.ll

@@ -10,32 +10,33 @@ 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) #0
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #1
 
 ; Function Attrs: nounwind
-define hidden void @main.init(ptr %context) unnamed_addr #1 {
+define hidden void @main.init(ptr %context) unnamed_addr #2 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.addInt(i32 %x, i32 %y, ptr %context) unnamed_addr #1 {
+define hidden i32 @main.addInt(i32 %x, i32 %y, ptr %context) unnamed_addr #2 {
 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 #1 {
+define hidden i1 @main.equalInt(i32 %x, i32 %y, ptr %context) unnamed_addr #2 {
 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 #1 {
+define hidden i32 @main.divInt(i32 %x, i32 %y, ptr %context) unnamed_addr #2 {
 entry:
   %0 = icmp eq i32 %y, 0
   br i1 %0, label %divbyzero.throw, label %divbyzero.next
@@ -49,14 +50,14 @@ divbyzero.next:                                   ; preds = %entry
   ret i32 %5
 
 divbyzero.throw:                                  ; preds = %entry
-  call void @runtime.divideByZeroPanic(ptr undef) #2
+  call void @runtime.divideByZeroPanic(ptr undef) #3
   unreachable
 }
 
-declare void @runtime.divideByZeroPanic(ptr) #0
+declare void @runtime.divideByZeroPanic(ptr) #1
 
 ; Function Attrs: nounwind
-define hidden i32 @main.divUint(i32 %x, i32 %y, ptr %context) unnamed_addr #1 {
+define hidden i32 @main.divUint(i32 %x, i32 %y, ptr %context) unnamed_addr #2 {
 entry:
   %0 = icmp eq i32 %y, 0
   br i1 %0, label %divbyzero.throw, label %divbyzero.next
@@ -66,12 +67,12 @@ divbyzero.next:                                   ; preds = %entry
   ret i32 %1
 
 divbyzero.throw:                                  ; preds = %entry
-  call void @runtime.divideByZeroPanic(ptr undef) #2
+  call void @runtime.divideByZeroPanic(ptr undef) #3
   unreachable
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.remInt(i32 %x, i32 %y, ptr %context) unnamed_addr #1 {
+define hidden i32 @main.remInt(i32 %x, i32 %y, ptr %context) unnamed_addr #2 {
 entry:
   %0 = icmp eq i32 %y, 0
   br i1 %0, label %divbyzero.throw, label %divbyzero.next
@@ -85,12 +86,12 @@ divbyzero.next:                                   ; preds = %entry
   ret i32 %5
 
 divbyzero.throw:                                  ; preds = %entry
-  call void @runtime.divideByZeroPanic(ptr undef) #2
+  call void @runtime.divideByZeroPanic(ptr undef) #3
   unreachable
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.remUint(i32 %x, i32 %y, ptr %context) unnamed_addr #1 {
+define hidden i32 @main.remUint(i32 %x, i32 %y, ptr %context) unnamed_addr #2 {
 entry:
   %0 = icmp eq i32 %y, 0
   br i1 %0, label %divbyzero.throw, label %divbyzero.next
@@ -100,66 +101,66 @@ divbyzero.next:                                   ; preds = %entry
   ret i32 %1
 
 divbyzero.throw:                                  ; preds = %entry
-  call void @runtime.divideByZeroPanic(ptr undef) #2
+  call void @runtime.divideByZeroPanic(ptr undef) #3
   unreachable
 }
 
 ; Function Attrs: nounwind
-define hidden i1 @main.floatEQ(float %x, float %y, ptr %context) unnamed_addr #1 {
+define hidden i1 @main.floatEQ(float %x, float %y, ptr %context) unnamed_addr #2 {
 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 #1 {
+define hidden i1 @main.floatNE(float %x, float %y, ptr %context) unnamed_addr #2 {
 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 #1 {
+define hidden i1 @main.floatLower(float %x, float %y, ptr %context) unnamed_addr #2 {
 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 #1 {
+define hidden i1 @main.floatLowerEqual(float %x, float %y, ptr %context) unnamed_addr #2 {
 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 #1 {
+define hidden i1 @main.floatGreater(float %x, float %y, ptr %context) unnamed_addr #2 {
 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 #1 {
+define hidden i1 @main.floatGreaterEqual(float %x, float %y, ptr %context) unnamed_addr #2 {
 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 #1 {
+define hidden float @main.complexReal(float %x.r, float %x.i, ptr %context) unnamed_addr #2 {
 entry:
   ret float %x.r
 }
 
 ; Function Attrs: nounwind
-define hidden float @main.complexImag(float %x.r, float %x.i, ptr %context) unnamed_addr #1 {
+define hidden float @main.complexImag(float %x.r, float %x.i, ptr %context) unnamed_addr #2 {
 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 #1 {
+define hidden { float, float } @main.complexAdd(float %x.r, float %x.i, float %y.r, float %y.i, ptr %context) unnamed_addr #2 {
 entry:
   %0 = fadd float %x.r, %y.r
   %1 = fadd float %x.i, %y.i
@@ -169,7 +170,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 #1 {
+define hidden { float, float } @main.complexSub(float %x.r, float %x.i, float %y.r, float %y.i, ptr %context) unnamed_addr #2 {
 entry:
   %0 = fsub float %x.r, %y.r
   %1 = fsub float %x.i, %y.i
@@ -179,7 +180,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 #1 {
+define hidden { float, float } @main.complexMul(float %x.r, float %x.i, float %y.r, float %y.i, ptr %context) unnamed_addr #2 {
 entry:
   %0 = fmul float %x.r, %y.r
   %1 = fmul float %x.i, %y.i
@@ -193,27 +194,28 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.foo(ptr %context) unnamed_addr #1 {
+define hidden void @main.foo(ptr %context) unnamed_addr #2 {
 entry:
   %complit = alloca %main.kv.0, align 8
   %stackalloc = alloca i8, align 1
   store %main.kv.0 zeroinitializer, ptr %complit, align 8
-  call void @runtime.trackPointer(ptr nonnull %complit, ptr nonnull %stackalloc, ptr undef) #2
+  call void @runtime.trackPointer(ptr nonnull %complit, ptr nonnull %stackalloc, ptr undef) #3
   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 #1 {
+define internal void @"main.foo$1"(%main.kv.0 %b, ptr %context) unnamed_addr #2 {
 entry:
   %b1 = alloca %main.kv.0, align 8
   %stackalloc = alloca i8, align 1
   store %main.kv.0 zeroinitializer, ptr %b1, align 8
-  call void @runtime.trackPointer(ptr nonnull %b1, ptr nonnull %stackalloc, ptr undef) #2
+  call void @runtime.trackPointer(ptr nonnull %b1, ptr nonnull %stackalloc, ptr undef) #3
   store %main.kv.0 %b, ptr %b1, align 8
   ret void
 }
 
-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 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #1 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #2 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #3 = { nounwind }

compiler/testdata/channel.ll

@@ -6,78 +6,79 @@ target triple = "wasm32-unknown-wasi"
 %runtime.channelBlockedList = type { ptr, ptr, ptr, { ptr, i32, i32 } }
 %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) #0
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #1
 
 ; Function Attrs: nounwind
-define hidden void @main.init(ptr %context) unnamed_addr #1 {
+define hidden void @main.init(ptr %context) unnamed_addr #2 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.chanIntSend(ptr dereferenceable_or_null(32) %ch, ptr %context) unnamed_addr #1 {
+define hidden void @main.chanIntSend(ptr dereferenceable_or_null(32) %ch, ptr %context) unnamed_addr #2 {
 entry:
   %chan.blockedList = alloca %runtime.channelBlockedList, 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 24, ptr nonnull %chan.blockedList)
-  call void @runtime.chanSend(ptr %ch, ptr nonnull %chan.value, ptr nonnull %chan.blockedList, ptr undef) #3
+  call void @runtime.chanSend(ptr %ch, ptr nonnull %chan.value, ptr nonnull %chan.blockedList, ptr undef) #4
   call void @llvm.lifetime.end.p0(i64 24, ptr nonnull %chan.blockedList)
   call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %chan.value)
   ret void
 }
 
 ; Function Attrs: argmemonly nocallback nofree nosync nounwind willreturn
-declare void @llvm.lifetime.start.p0(i64 immarg, ptr nocapture) #2
+declare void @llvm.lifetime.start.p0(i64 immarg, ptr nocapture) #3
 
-declare void @runtime.chanSend(ptr dereferenceable_or_null(32), ptr, ptr dereferenceable_or_null(24), ptr) #0
+declare void @runtime.chanSend(ptr dereferenceable_or_null(32), ptr, ptr dereferenceable_or_null(24), ptr) #1
 
 ; Function Attrs: argmemonly nocallback nofree nosync nounwind willreturn
-declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #2
+declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #3
 
 ; Function Attrs: nounwind
-define hidden void @main.chanIntRecv(ptr dereferenceable_or_null(32) %ch, ptr %context) unnamed_addr #1 {
+define hidden void @main.chanIntRecv(ptr dereferenceable_or_null(32) %ch, ptr %context) unnamed_addr #2 {
 entry:
   %chan.blockedList = alloca %runtime.channelBlockedList, 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 24, ptr nonnull %chan.blockedList)
-  %0 = call i1 @runtime.chanRecv(ptr %ch, ptr nonnull %chan.value, ptr nonnull %chan.blockedList, ptr undef) #3
+  %0 = call i1 @runtime.chanRecv(ptr %ch, ptr nonnull %chan.value, ptr nonnull %chan.blockedList, ptr undef) #4
   call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %chan.value)
   call void @llvm.lifetime.end.p0(i64 24, ptr nonnull %chan.blockedList)
   ret void
 }
 
-declare i1 @runtime.chanRecv(ptr dereferenceable_or_null(32), ptr, ptr dereferenceable_or_null(24), ptr) #0
+declare i1 @runtime.chanRecv(ptr dereferenceable_or_null(32), ptr, ptr dereferenceable_or_null(24), ptr) #1
 
 ; Function Attrs: nounwind
-define hidden void @main.chanZeroSend(ptr dereferenceable_or_null(32) %ch, ptr %context) unnamed_addr #1 {
+define hidden void @main.chanZeroSend(ptr dereferenceable_or_null(32) %ch, ptr %context) unnamed_addr #2 {
 entry:
   %complit = alloca {}, align 8
   %chan.blockedList = alloca %runtime.channelBlockedList, align 8
   %stackalloc = alloca i8, align 1
-  call void @runtime.trackPointer(ptr nonnull %complit, ptr nonnull %stackalloc, ptr undef) #3
+  call void @runtime.trackPointer(ptr nonnull %complit, ptr nonnull %stackalloc, ptr undef) #4
   call void @llvm.lifetime.start.p0(i64 24, ptr nonnull %chan.blockedList)
-  call void @runtime.chanSend(ptr %ch, ptr null, ptr nonnull %chan.blockedList, ptr undef) #3
+  call void @runtime.chanSend(ptr %ch, ptr null, ptr nonnull %chan.blockedList, ptr undef) #4
   call void @llvm.lifetime.end.p0(i64 24, ptr nonnull %chan.blockedList)
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.chanZeroRecv(ptr dereferenceable_or_null(32) %ch, ptr %context) unnamed_addr #1 {
+define hidden void @main.chanZeroRecv(ptr dereferenceable_or_null(32) %ch, ptr %context) unnamed_addr #2 {
 entry:
   %chan.blockedList = alloca %runtime.channelBlockedList, align 8
   call void @llvm.lifetime.start.p0(i64 24, ptr nonnull %chan.blockedList)
-  %0 = call i1 @runtime.chanRecv(ptr %ch, ptr null, ptr nonnull %chan.blockedList, ptr undef) #3
+  %0 = call i1 @runtime.chanRecv(ptr %ch, ptr null, ptr nonnull %chan.blockedList, ptr undef) #4
   call void @llvm.lifetime.end.p0(i64 24, ptr nonnull %chan.blockedList)
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.selectZeroRecv(ptr dereferenceable_or_null(32) %ch1, ptr dereferenceable_or_null(32) %ch2, ptr %context) unnamed_addr #1 {
+define hidden void @main.selectZeroRecv(ptr dereferenceable_or_null(32) %ch1, ptr dereferenceable_or_null(32) %ch2, ptr %context) unnamed_addr #2 {
 entry:
   %select.states.alloca = alloca [2 x %runtime.chanSelectState], align 8
   %select.send.value = alloca i32, align 4
@@ -90,7 +91,7 @@ entry:
   store ptr %ch2, ptr %0, align 8
   %.repack3 = getelementptr inbounds [2 x %runtime.chanSelectState], ptr %select.states.alloca, i32 0, i32 1, i32 1
   store ptr null, ptr %.repack3, align 4
-  %select.result = call { i32, i1 } @runtime.tryChanSelect(ptr undef, ptr nonnull %select.states.alloca, i32 2, i32 2, ptr undef) #3
+  %select.result = call { i32, i1 } @runtime.tryChanSelect(ptr undef, ptr nonnull %select.states.alloca, i32 2, i32 2, ptr undef) #4
   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
@@ -107,9 +108,10 @@ select.body:                                      ; preds = %select.next
   br label %select.done
 }
 
-declare { i32, i1 } @runtime.tryChanSelect(ptr, ptr, i32, i32, ptr) #0
+declare { i32, i1 } @runtime.tryChanSelect(ptr, ptr, i32, i32, ptr) #1
 
-attributes #0 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
-attributes #1 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
-attributes #2 = { argmemonly nocallback nofree nosync nounwind willreturn }
-attributes #3 = { nounwind }
+attributes #0 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #1 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #2 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #3 = { argmemonly nocallback nofree nosync nounwind willreturn }
+attributes #4 = { nounwind }

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

@@ -4,9 +4,10 @@ target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
 target triple = "thumbv7m-unknown-unknown-eabi"
 
 %runtime.deferFrame = type { ptr, ptr, [0 x ptr], ptr, i1, %runtime._interface }
-%runtime._interface = type { i32, ptr }
+%runtime._interface = type { ptr, ptr }
 %runtime._defer = type { i32, ptr }
 
+; Function Attrs: allockind("alloc,zeroed") allocsize(0)
 declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #0
 
 ; Function Attrs: nounwind
@@ -15,7 +16,7 @@ entry:
   ret void
 }
 
-declare void @main.external(ptr) #0
+declare void @main.external(ptr) #2
 
 ; Function Attrs: nounwind
 define hidden void @main.deferSimple(ptr %context) unnamed_addr #1 {
@@ -25,17 +26,17 @@ entry:
   store ptr null, ptr %deferPtr, align 4
   %deferframe.buf = alloca %runtime.deferFrame, align 4
   %0 = call ptr @llvm.stacksave()
-  call void @runtime.setupDeferFrame(ptr nonnull %deferframe.buf, ptr %0, ptr undef) #3
+  call void @runtime.setupDeferFrame(ptr nonnull %deferframe.buf, ptr %0, ptr undef) #4
   store i32 0, ptr %defer.alloca, align 4
   %defer.alloca.repack15 = getelementptr inbounds { i32, ptr }, ptr %defer.alloca, i32 0, i32 1
   store ptr null, ptr %defer.alloca.repack15, align 4
   store ptr %defer.alloca, ptr %deferPtr, align 4
-  %setjmp = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(ptr nonnull %deferframe.buf) #4
+  %setjmp = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(ptr nonnull %deferframe.buf) #5
   %setjmp.result = icmp eq i32 %setjmp, 0
   br i1 %setjmp.result, label %1, label %lpad
 
 1:                                                ; preds = %entry
-  call void @main.external(ptr undef) #3
+  call void @main.external(ptr undef) #4
   br label %rundefers.loophead
 
 rundefers.loophead:                               ; preds = %3, %1
@@ -53,7 +54,7 @@ rundefers.loop:                                   ; preds = %rundefers.loophead
   ]
 
 rundefers.callback0:                              ; preds = %rundefers.loop
-  %setjmp1 = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(ptr nonnull %deferframe.buf) #4
+  %setjmp1 = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(ptr nonnull %deferframe.buf) #5
   %setjmp.result2 = icmp eq i32 %setjmp1, 0
   br i1 %setjmp.result2, label %3, label %lpad
 
@@ -65,11 +66,11 @@ rundefers.default:                                ; preds = %rundefers.loop
   unreachable
 
 rundefers.end:                                    ; preds = %rundefers.loophead
-  call void @runtime.destroyDeferFrame(ptr nonnull %deferframe.buf, ptr undef) #3
+  call void @runtime.destroyDeferFrame(ptr nonnull %deferframe.buf, ptr undef) #4
   ret void
 
 recover:                                          ; preds = %rundefers.end3
-  call void @runtime.destroyDeferFrame(ptr nonnull %deferframe.buf, ptr undef) #3
+  call void @runtime.destroyDeferFrame(ptr nonnull %deferframe.buf, ptr undef) #4
   ret void
 
 lpad:                                             ; preds = %rundefers.callback012, %rundefers.callback0, %entry
@@ -90,7 +91,7 @@ rundefers.loop5:                                  ; preds = %rundefers.loophead6
   ]
 
 rundefers.callback012:                            ; preds = %rundefers.loop5
-  %setjmp13 = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(ptr nonnull %deferframe.buf) #4
+  %setjmp13 = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(ptr nonnull %deferframe.buf) #5
   %setjmp.result14 = icmp eq i32 %setjmp13, 0
   br i1 %setjmp.result14, label %5, label %lpad
 
@@ -106,20 +107,20 @@ rundefers.end3:                                   ; preds = %rundefers.loophead6
 }
 
 ; Function Attrs: nocallback nofree nosync nounwind willreturn
-declare ptr @llvm.stacksave() #2
+declare ptr @llvm.stacksave() #3
 
-declare void @runtime.setupDeferFrame(ptr dereferenceable_or_null(24), ptr, ptr) #0
+declare void @runtime.setupDeferFrame(ptr dereferenceable_or_null(24), ptr, ptr) #2
 
 ; Function Attrs: nounwind
 define internal void @"main.deferSimple$1"(ptr %context) unnamed_addr #1 {
 entry:
-  call void @runtime.printint32(i32 3, ptr undef) #3
+  call void @runtime.printint32(i32 3, ptr undef) #4
   ret void
 }
 
-declare void @runtime.destroyDeferFrame(ptr dereferenceable_or_null(24), ptr) #0
+declare void @runtime.destroyDeferFrame(ptr dereferenceable_or_null(24), ptr) #2
 
-declare void @runtime.printint32(i32, ptr) #0
+declare void @runtime.printint32(i32, ptr) #2
 
 ; Function Attrs: nounwind
 define hidden void @main.deferMultiple(ptr %context) unnamed_addr #1 {
@@ -130,7 +131,7 @@ entry:
   store ptr null, ptr %deferPtr, align 4
   %deferframe.buf = alloca %runtime.deferFrame, align 4
   %0 = call ptr @llvm.stacksave()
-  call void @runtime.setupDeferFrame(ptr nonnull %deferframe.buf, ptr %0, ptr undef) #3
+  call void @runtime.setupDeferFrame(ptr nonnull %deferframe.buf, ptr %0, ptr undef) #4
   store i32 0, ptr %defer.alloca, align 4
   %defer.alloca.repack22 = getelementptr inbounds { i32, ptr }, ptr %defer.alloca, i32 0, i32 1
   store ptr null, ptr %defer.alloca.repack22, align 4
@@ -139,12 +140,12 @@ entry:
   %defer.alloca2.repack23 = getelementptr inbounds { i32, ptr }, ptr %defer.alloca2, i32 0, i32 1
   store ptr %defer.alloca, ptr %defer.alloca2.repack23, align 4
   store ptr %defer.alloca2, ptr %deferPtr, align 4
-  %setjmp = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(ptr nonnull %deferframe.buf) #4
+  %setjmp = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(ptr nonnull %deferframe.buf) #5
   %setjmp.result = icmp eq i32 %setjmp, 0
   br i1 %setjmp.result, label %1, label %lpad
 
 1:                                                ; preds = %entry
-  call void @main.external(ptr undef) #3
+  call void @main.external(ptr undef) #4
   br label %rundefers.loophead
 
 rundefers.loophead:                               ; preds = %4, %3, %1
@@ -163,7 +164,7 @@ rundefers.loop:                                   ; preds = %rundefers.loophead
   ]
 
 rundefers.callback0:                              ; preds = %rundefers.loop
-  %setjmp3 = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(ptr nonnull %deferframe.buf) #4
+  %setjmp3 = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(ptr nonnull %deferframe.buf) #5
   %setjmp.result4 = icmp eq i32 %setjmp3, 0
   br i1 %setjmp.result4, label %3, label %lpad
 
@@ -172,7 +173,7 @@ rundefers.callback0:                              ; preds = %rundefers.loop
   br label %rundefers.loophead
 
 rundefers.callback1:                              ; preds = %rundefers.loop
-  %setjmp5 = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(ptr nonnull %deferframe.buf) #4
+  %setjmp5 = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(ptr nonnull %deferframe.buf) #5
   %setjmp.result6 = icmp eq i32 %setjmp5, 0
   br i1 %setjmp.result6, label %4, label %lpad
 
@@ -184,11 +185,11 @@ rundefers.default:                                ; preds = %rundefers.loop
   unreachable
 
 rundefers.end:                                    ; preds = %rundefers.loophead
-  call void @runtime.destroyDeferFrame(ptr nonnull %deferframe.buf, ptr undef) #3
+  call void @runtime.destroyDeferFrame(ptr nonnull %deferframe.buf, ptr undef) #4
   ret void
 
 recover:                                          ; preds = %rundefers.end7
-  call void @runtime.destroyDeferFrame(ptr nonnull %deferframe.buf, ptr undef) #3
+  call void @runtime.destroyDeferFrame(ptr nonnull %deferframe.buf, ptr undef) #4
   ret void
 
 lpad:                                             ; preds = %rundefers.callback119, %rundefers.callback016, %rundefers.callback1, %rundefers.callback0, %entry
@@ -210,7 +211,7 @@ rundefers.loop9:                                  ; preds = %rundefers.loophead1
   ]
 
 rundefers.callback016:                            ; preds = %rundefers.loop9
-  %setjmp17 = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(ptr nonnull %deferframe.buf) #4
+  %setjmp17 = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(ptr nonnull %deferframe.buf) #5
   %setjmp.result18 = icmp eq i32 %setjmp17, 0
   br i1 %setjmp.result18, label %6, label %lpad
 
@@ -219,7 +220,7 @@ rundefers.callback016:                            ; preds = %rundefers.loop9
   br label %rundefers.loophead10
 
 rundefers.callback119:                            ; preds = %rundefers.loop9
-  %setjmp20 = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(ptr nonnull %deferframe.buf) #4
+  %setjmp20 = call i32 asm "\0Amovs r0, #0\0Amov r2, pc\0Astr r2, [r1, #4]", "={r0},{r1},~{r1},~{r2},~{r3},~{r4},~{r5},~{r6},~{r7},~{r8},~{r9},~{r10},~{r11},~{r12},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{cpsr},~{memory}"(ptr nonnull %deferframe.buf) #5
   %setjmp.result21 = icmp eq i32 %setjmp20, 0
   br i1 %setjmp.result21, label %7, label %lpad
 
@@ -237,19 +238,20 @@ rundefers.end7:                                   ; preds = %rundefers.loophead1
 ; Function Attrs: nounwind
 define internal void @"main.deferMultiple$1"(ptr %context) unnamed_addr #1 {
 entry:
-  call void @runtime.printint32(i32 3, ptr undef) #3
+  call void @runtime.printint32(i32 3, ptr undef) #4
   ret void
 }
 
 ; Function Attrs: nounwind
 define internal void @"main.deferMultiple$2"(ptr %context) unnamed_addr #1 {
 entry:
-  call void @runtime.printint32(i32 5, ptr undef) #3
+  call void @runtime.printint32(i32 5, ptr undef) #4
   ret void
 }
 
-attributes #0 = { "target-features"="+armv7-m,+hwdiv,+soft-float,+strict-align,+thumb-mode,-aes,-bf16,-cdecp0,-cdecp1,-cdecp2,-cdecp3,-cdecp4,-cdecp5,-cdecp6,-cdecp7,-crc,-crypto,-d32,-dotprod,-dsp,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fp64,-fpregs,-fullfp16,-hwdiv-arm,-i8mm,-lob,-mve,-mve.fp,-neon,-pacbti,-ras,-sb,-sha2,-vfp2,-vfp2sp,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp" }
+attributes #0 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+armv7-m,+hwdiv,+soft-float,+strict-align,+thumb-mode,-aes,-bf16,-cdecp0,-cdecp1,-cdecp2,-cdecp3,-cdecp4,-cdecp5,-cdecp6,-cdecp7,-crc,-crypto,-d32,-dotprod,-dsp,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fp64,-fpregs,-fullfp16,-hwdiv-arm,-i8mm,-lob,-mve,-mve.fp,-neon,-pacbti,-ras,-sb,-sha2,-vfp2,-vfp2sp,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp" }
 attributes #1 = { nounwind "target-features"="+armv7-m,+hwdiv,+soft-float,+strict-align,+thumb-mode,-aes,-bf16,-cdecp0,-cdecp1,-cdecp2,-cdecp3,-cdecp4,-cdecp5,-cdecp6,-cdecp7,-crc,-crypto,-d32,-dotprod,-dsp,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fp64,-fpregs,-fullfp16,-hwdiv-arm,-i8mm,-lob,-mve,-mve.fp,-neon,-pacbti,-ras,-sb,-sha2,-vfp2,-vfp2sp,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp" }
-attributes #2 = { nocallback nofree nosync nounwind willreturn }
-attributes #3 = { nounwind }
-attributes #4 = { nounwind returns_twice }
+attributes #2 = { "target-features"="+armv7-m,+hwdiv,+soft-float,+strict-align,+thumb-mode,-aes,-bf16,-cdecp0,-cdecp1,-cdecp2,-cdecp3,-cdecp4,-cdecp5,-cdecp6,-cdecp7,-crc,-crypto,-d32,-dotprod,-dsp,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fp64,-fpregs,-fullfp16,-hwdiv-arm,-i8mm,-lob,-mve,-mve.fp,-neon,-pacbti,-ras,-sb,-sha2,-vfp2,-vfp2sp,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp" }
+attributes #3 = { nocallback nofree nosync nounwind willreturn }
+attributes #4 = { nounwind }
+attributes #5 = { nounwind returns_twice }

compiler/testdata/float.ll

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

compiler/testdata/func.ll

@@ -3,46 +3,48 @@ source_filename = "func.go"
 target datalayout = "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-n32:64-S128-ni:1:10:20"
 target triple = "wasm32-unknown-wasi"
 
+; 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) #0
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #1
 
 ; Function Attrs: nounwind
-define hidden void @main.init(ptr %context) unnamed_addr #1 {
+define hidden void @main.init(ptr %context) unnamed_addr #2 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.foo(ptr %callback.context, ptr %callback.funcptr, ptr %context) unnamed_addr #1 {
+define hidden void @main.foo(ptr %callback.context, ptr %callback.funcptr, ptr %context) unnamed_addr #2 {
 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) #2
+  call void %callback.funcptr(i32 3, ptr %callback.context) #3
   ret void
 
 fpcall.throw:                                     ; preds = %entry
-  call void @runtime.nilPanic(ptr undef) #2
+  call void @runtime.nilPanic(ptr undef) #3
   unreachable
 }
 
-declare void @runtime.nilPanic(ptr) #0
+declare void @runtime.nilPanic(ptr) #1
 
 ; Function Attrs: nounwind
-define hidden void @main.bar(ptr %context) unnamed_addr #1 {
+define hidden void @main.bar(ptr %context) unnamed_addr #2 {
 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 #1 {
+define hidden void @main.someFunc(i32 %arg0, ptr %context) unnamed_addr #2 {
 entry:
   ret void
 }
 
-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 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #1 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #2 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #3 = { nounwind }

compiler/testdata/gc.ll

@@ -3,8 +3,7 @@ source_filename = "gc.go"
 target datalayout = "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-n32:64-S128-ni:1:10:20"
 target triple = "wasm32-unknown-wasi"
 
-%runtime.typecodeID = type { ptr, i32, ptr, ptr, i32 }
-%runtime._interface = type { i32, ptr }
+%runtime._interface = type { ptr, ptr }
 
 @main.scalar1 = hidden global ptr null, align 4
 @main.scalar2 = hidden global ptr null, align 4
@@ -22,98 +21,99 @@ target triple = "wasm32-unknown-wasi"
 @main.slice3 = hidden global { ptr, i32, i32 } zeroinitializer, align 8
 @"runtime/gc.layout:62-2000000000000001" = linkonce_odr unnamed_addr constant { i32, [8 x i8] } { i32 62, [8 x i8] c"\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" }
-@"reflect/types.type:basic:complex128" = linkonce_odr constant %runtime.typecodeID { ptr null, i32 0, ptr null, ptr @"reflect/types.type:pointer:basic:complex128", i32 0 }
-@"reflect/types.type:pointer:basic:complex128" = linkonce_odr constant %runtime.typecodeID { ptr @"reflect/types.type:basic:complex128", i32 0, ptr null, ptr null, i32 0 }
+@"reflect/types.type:basic:complex128" = linkonce_odr constant { i8, ptr } { i8 16, ptr @"reflect/types.type:pointer:basic:complex128" }, align 4
+@"reflect/types.type:pointer:basic:complex128" = linkonce_odr constant { i8, i16, ptr } { i8 21, 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) #0
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #1
 
 ; Function Attrs: nounwind
-define hidden void @main.init(ptr %context) unnamed_addr #1 {
+define hidden void @main.init(ptr %context) unnamed_addr #2 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.newScalar(ptr %context) unnamed_addr #1 {
+define hidden void @main.newScalar(ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
-  %new = call ptr @runtime.alloc(i32 1, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #2
-  call void @runtime.trackPointer(ptr nonnull %new, ptr nonnull %stackalloc, ptr undef) #2
+  %new = call dereferenceable(1) ptr @runtime.alloc(i32 1, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
+  call void @runtime.trackPointer(ptr nonnull %new, ptr nonnull %stackalloc, ptr undef) #3
   store ptr %new, ptr @main.scalar1, align 4
-  %new1 = call ptr @runtime.alloc(i32 4, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #2
-  call void @runtime.trackPointer(ptr nonnull %new1, ptr nonnull %stackalloc, ptr undef) #2
+  %new1 = call dereferenceable(4) ptr @runtime.alloc(i32 4, 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.scalar2, align 4
-  %new2 = call ptr @runtime.alloc(i32 8, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #2
-  call void @runtime.trackPointer(ptr nonnull %new2, ptr nonnull %stackalloc, ptr undef) #2
+  %new2 = call dereferenceable(8) ptr @runtime.alloc(i32 8, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
+  call void @runtime.trackPointer(ptr nonnull %new2, ptr nonnull %stackalloc, ptr undef) #3
   store ptr %new2, ptr @main.scalar3, align 4
-  %new3 = call ptr @runtime.alloc(i32 4, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #2
-  call void @runtime.trackPointer(ptr nonnull %new3, ptr nonnull %stackalloc, ptr undef) #2
+  %new3 = call dereferenceable(4) ptr @runtime.alloc(i32 4, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
+  call void @runtime.trackPointer(ptr nonnull %new3, ptr nonnull %stackalloc, ptr undef) #3
   store ptr %new3, ptr @main.scalar4, align 4
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.newArray(ptr %context) unnamed_addr #1 {
+define hidden void @main.newArray(ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
-  %new = call ptr @runtime.alloc(i32 3, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #2
-  call void @runtime.trackPointer(ptr nonnull %new, ptr nonnull %stackalloc, ptr undef) #2
+  %new = call dereferenceable(3) ptr @runtime.alloc(i32 3, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
+  call void @runtime.trackPointer(ptr nonnull %new, ptr nonnull %stackalloc, ptr undef) #3
   store ptr %new, ptr @main.array1, align 4
-  %new1 = call ptr @runtime.alloc(i32 71, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #2
-  call void @runtime.trackPointer(ptr nonnull %new1, ptr nonnull %stackalloc, ptr undef) #2
+  %new1 = call dereferenceable(71) ptr @runtime.alloc(i32 71, 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.array2, align 4
-  %new2 = call ptr @runtime.alloc(i32 12, ptr nonnull inttoptr (i32 67 to ptr), ptr undef) #2
-  call void @runtime.trackPointer(ptr nonnull %new2, ptr nonnull %stackalloc, ptr undef) #2
+  %new2 = call dereferenceable(12) ptr @runtime.alloc(i32 12, ptr nonnull inttoptr (i32 67 to ptr), ptr undef) #3
+  call void @runtime.trackPointer(ptr nonnull %new2, ptr nonnull %stackalloc, ptr undef) #3
   store ptr %new2, ptr @main.array3, align 4
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.newStruct(ptr %context) unnamed_addr #1 {
+define hidden void @main.newStruct(ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
-  %new = call ptr @runtime.alloc(i32 0, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #2
-  call void @runtime.trackPointer(ptr nonnull %new, ptr nonnull %stackalloc, ptr undef) #2
+  %new = call ptr @runtime.alloc(i32 0, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
+  call void @runtime.trackPointer(ptr nonnull %new, ptr nonnull %stackalloc, ptr undef) #3
   store ptr %new, ptr @main.struct1, align 4
-  %new1 = call ptr @runtime.alloc(i32 8, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #2
-  call void @runtime.trackPointer(ptr nonnull %new1, ptr nonnull %stackalloc, ptr undef) #2
+  %new1 = call 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 ptr @runtime.alloc(i32 248, ptr nonnull @"runtime/gc.layout:62-2000000000000001", ptr undef) #2
-  call void @runtime.trackPointer(ptr nonnull %new2, ptr nonnull %stackalloc, ptr undef) #2
+  %new2 = call dereferenceable(248) ptr @runtime.alloc(i32 248, ptr nonnull @"runtime/gc.layout:62-2000000000000001", 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 ptr @runtime.alloc(i32 248, ptr nonnull @"runtime/gc.layout:62-0001", ptr undef) #2
-  call void @runtime.trackPointer(ptr nonnull %new3, ptr nonnull %stackalloc, ptr undef) #2
+  %new3 = call dereferenceable(248) ptr @runtime.alloc(i32 248, ptr nonnull @"runtime/gc.layout:62-0001", ptr undef) #3
+  call void @runtime.trackPointer(ptr nonnull %new3, ptr nonnull %stackalloc, ptr undef) #3
   store ptr %new3, ptr @main.struct4, align 4
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden ptr @main.newFuncValue(ptr %context) unnamed_addr #1 {
+define hidden ptr @main.newFuncValue(ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
-  %new = call ptr @runtime.alloc(i32 8, ptr nonnull inttoptr (i32 197 to ptr), ptr undef) #2
-  call void @runtime.trackPointer(ptr nonnull %new, ptr nonnull %stackalloc, ptr undef) #2
+  %new = call dereferenceable(8) ptr @runtime.alloc(i32 8, ptr nonnull inttoptr (i32 197 to ptr), ptr undef) #3
+  call void @runtime.trackPointer(ptr nonnull %new, ptr nonnull %stackalloc, ptr undef) #3
   ret ptr %new
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.makeSlice(ptr %context) unnamed_addr #1 {
+define hidden void @main.makeSlice(ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
-  %makeslice = call ptr @runtime.alloc(i32 5, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #2
-  call void @runtime.trackPointer(ptr nonnull %makeslice, ptr nonnull %stackalloc, ptr undef) #2
+  %makeslice = call dereferenceable(5) ptr @runtime.alloc(i32 5, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
+  call void @runtime.trackPointer(ptr nonnull %makeslice, ptr nonnull %stackalloc, ptr undef) #3
   store ptr %makeslice, ptr @main.slice1, align 8
   store i32 5, ptr getelementptr inbounds ({ ptr, i32, i32 }, ptr @main.slice1, i32 0, i32 1), align 4
   store i32 5, ptr getelementptr inbounds ({ ptr, i32, i32 }, ptr @main.slice1, i32 0, i32 2), align 8
-  %makeslice1 = call ptr @runtime.alloc(i32 20, ptr nonnull inttoptr (i32 67 to ptr), ptr undef) #2
-  call void @runtime.trackPointer(ptr nonnull %makeslice1, ptr nonnull %stackalloc, ptr undef) #2
+  %makeslice1 = call dereferenceable(20) ptr @runtime.alloc(i32 20, ptr nonnull inttoptr (i32 67 to ptr), ptr undef) #3
+  call void @runtime.trackPointer(ptr nonnull %makeslice1, ptr nonnull %stackalloc, ptr undef) #3
   store ptr %makeslice1, ptr @main.slice2, align 8
   store i32 5, ptr getelementptr inbounds ({ ptr, i32, i32 }, ptr @main.slice2, i32 0, i32 1), align 4
   store i32 5, ptr getelementptr inbounds ({ ptr, i32, i32 }, ptr @main.slice2, i32 0, i32 2), align 8
-  %makeslice3 = call ptr @runtime.alloc(i32 60, ptr nonnull inttoptr (i32 71 to ptr), ptr undef) #2
-  call void @runtime.trackPointer(ptr nonnull %makeslice3, ptr nonnull %stackalloc, ptr undef) #2
+  %makeslice3 = call dereferenceable(60) ptr @runtime.alloc(i32 60, ptr nonnull inttoptr (i32 71 to ptr), ptr undef) #3
+  call void @runtime.trackPointer(ptr nonnull %makeslice3, ptr nonnull %stackalloc, ptr undef) #3
   store ptr %makeslice3, ptr @main.slice3, align 8
   store i32 5, ptr getelementptr inbounds ({ ptr, i32, i32 }, ptr @main.slice3, i32 0, i32 1), align 4
   store i32 5, ptr getelementptr inbounds ({ ptr, i32, i32 }, ptr @main.slice3, i32 0, i32 2), align 8
@@ -121,19 +121,21 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden %runtime._interface @main.makeInterface(double %v.r, double %v.i, ptr %context) unnamed_addr #1 {
+define hidden %runtime._interface @main.makeInterface(double %v.r, double %v.i, ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
-  %0 = call ptr @runtime.alloc(i32 16, ptr null, ptr undef) #2
-  call void @runtime.trackPointer(ptr nonnull %0, ptr nonnull %stackalloc, ptr undef) #2
+  %0 = call dereferenceable(16) ptr @runtime.alloc(i32 16, ptr null, ptr undef) #3
+  call void @runtime.trackPointer(ptr nonnull %0, ptr nonnull %stackalloc, ptr undef) #3
   store double %v.r, ptr %0, align 8
   %.repack1 = getelementptr inbounds { double, double }, ptr %0, i32 0, i32 1
   store double %v.i, ptr %.repack1, align 8
-  %1 = insertvalue %runtime._interface { i32 ptrtoint (ptr @"reflect/types.type:basic:complex128" to i32), ptr undef }, ptr %0, 1
-  call void @runtime.trackPointer(ptr nonnull %0, ptr nonnull %stackalloc, ptr undef) #2
+  %1 = insertvalue %runtime._interface { ptr @"reflect/types.type:basic:complex128", ptr undef }, ptr %0, 1
+  call void @runtime.trackPointer(ptr nonnull @"reflect/types.type:basic:complex128", ptr nonnull %stackalloc, ptr undef) #3
+  call void @runtime.trackPointer(ptr nonnull %0, ptr nonnull %stackalloc, ptr undef) #3
   ret %runtime._interface %1
 }
 
-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 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #1 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #2 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #3 = { nounwind }

compiler/testdata/go1.20.ll

@@ -5,26 +5,27 @@ 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) #0
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #1
 
 ; Function Attrs: nounwind
-define hidden void @main.init(ptr %context) unnamed_addr #1 {
+define hidden void @main.init(ptr %context) unnamed_addr #2 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden ptr @main.unsafeSliceData(ptr %s.data, i32 %s.len, i32 %s.cap, ptr %context) unnamed_addr #1 {
+define hidden ptr @main.unsafeSliceData(ptr %s.data, i32 %s.len, i32 %s.cap, ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
-  call void @runtime.trackPointer(ptr %s.data, ptr nonnull %stackalloc, ptr undef) #2
+  call void @runtime.trackPointer(ptr %s.data, ptr nonnull %stackalloc, ptr undef) #3
   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 #1 {
+define hidden %runtime._string @main.unsafeString(ptr dereferenceable_or_null(1) %ptr, i16 %len, ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
   %0 = icmp slt i16 %len, 0
@@ -38,24 +39,25 @@ unsafe.String.next:                               ; preds = %entry
   %5 = zext 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) #2
+  call void @runtime.trackPointer(ptr %ptr, ptr nonnull %stackalloc, ptr undef) #3
   ret %runtime._string %7
 
 unsafe.String.throw:                              ; preds = %entry
-  call void @runtime.unsafeSlicePanic(ptr undef) #2
+  call void @runtime.unsafeSlicePanic(ptr undef) #3
   unreachable
 }
 
-declare void @runtime.unsafeSlicePanic(ptr) #0
+declare void @runtime.unsafeSlicePanic(ptr) #1
 
 ; Function Attrs: nounwind
-define hidden ptr @main.unsafeStringData(ptr %s.data, i32 %s.len, ptr %context) unnamed_addr #1 {
+define hidden ptr @main.unsafeStringData(ptr %s.data, i32 %s.len, ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
-  call void @runtime.trackPointer(ptr %s.data, ptr nonnull %stackalloc, ptr undef) #2
+  call void @runtime.trackPointer(ptr %s.data, ptr nonnull %stackalloc, ptr undef) #3
   ret ptr %s.data
 }
 
-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 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #1 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #2 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #3 = { nounwind }

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

@@ -7,6 +7,7 @@ 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
@@ -18,30 +19,30 @@ entry:
 ; Function Attrs: nounwind
 define hidden void @main.regularFunctionGoroutine(ptr %context) unnamed_addr #1 {
 entry:
-  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (ptr @"main.regularFunction$gowrapper" to i32), ptr undef) #8
-  call void @"internal/task.start"(i32 ptrtoint (ptr @"main.regularFunction$gowrapper" to i32), ptr nonnull inttoptr (i32 5 to ptr), i32 %stacksize, ptr undef) #8
+  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (ptr @"main.regularFunction$gowrapper" to i32), ptr undef) #9
+  call void @"internal/task.start"(i32 ptrtoint (ptr @"main.regularFunction$gowrapper" to i32), ptr nonnull inttoptr (i32 5 to ptr), i32 %stacksize, ptr undef) #9
   ret void
 }
 
-declare void @main.regularFunction(i32, ptr) #0
+declare void @main.regularFunction(i32, ptr) #2
 
 ; Function Attrs: nounwind
-define linkonce_odr void @"main.regularFunction$gowrapper"(ptr %0) unnamed_addr #2 {
+define linkonce_odr void @"main.regularFunction$gowrapper"(ptr %0) unnamed_addr #3 {
 entry:
   %unpack.int = ptrtoint ptr %0 to i32
-  call void @main.regularFunction(i32 %unpack.int, ptr undef) #8
+  call void @main.regularFunction(i32 %unpack.int, ptr undef) #9
   ret void
 }
 
-declare i32 @"internal/task.getGoroutineStackSize"(i32, ptr) #0
+declare i32 @"internal/task.getGoroutineStackSize"(i32, ptr) #2
 
-declare void @"internal/task.start"(i32, ptr, i32, ptr) #0
+declare void @"internal/task.start"(i32, ptr, i32, ptr) #2
 
 ; Function Attrs: nounwind
 define hidden void @main.inlineFunctionGoroutine(ptr %context) unnamed_addr #1 {
 entry:
-  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (ptr @"main.inlineFunctionGoroutine$1$gowrapper" to i32), ptr undef) #8
-  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) #8
+  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (ptr @"main.inlineFunctionGoroutine$1$gowrapper" to i32), ptr undef) #9
+  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) #9
   ret void
 }
 
@@ -52,7 +53,7 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define linkonce_odr void @"main.inlineFunctionGoroutine$1$gowrapper"(ptr %0) unnamed_addr #3 {
+define linkonce_odr void @"main.inlineFunctionGoroutine$1$gowrapper"(ptr %0) unnamed_addr #4 {
 entry:
   %unpack.int = ptrtoint ptr %0 to i32
   call void @"main.inlineFunctionGoroutine$1"(i32 %unpack.int, ptr undef)
@@ -62,16 +63,16 @@ entry:
 ; Function Attrs: nounwind
 define hidden void @main.closureFunctionGoroutine(ptr %context) unnamed_addr #1 {
 entry:
-  %n = call ptr @runtime.alloc(i32 4, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #8
+  %n = call dereferenceable(4) ptr @runtime.alloc(i32 4, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #9
   store i32 3, ptr %n, align 4
-  %0 = call ptr @runtime.alloc(i32 8, ptr null, ptr undef) #8
+  %0 = call dereferenceable(8) ptr @runtime.alloc(i32 8, ptr null, ptr undef) #9
   store i32 5, ptr %0, align 4
   %1 = getelementptr inbounds { i32, ptr }, ptr %0, i32 0, i32 1
   store ptr %n, ptr %1, align 4
-  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (ptr @"main.closureFunctionGoroutine$1$gowrapper" to i32), ptr undef) #8
-  call void @"internal/task.start"(i32 ptrtoint (ptr @"main.closureFunctionGoroutine$1$gowrapper" to i32), ptr nonnull %0, i32 %stacksize, ptr undef) #8
+  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (ptr @"main.closureFunctionGoroutine$1$gowrapper" to i32), ptr undef) #9
+  call void @"internal/task.start"(i32 ptrtoint (ptr @"main.closureFunctionGoroutine$1$gowrapper" to i32), ptr nonnull %0, i32 %stacksize, ptr undef) #9
   %2 = load i32, ptr %n, align 4
-  call void @runtime.printint32(i32 %2, ptr undef) #8
+  call void @runtime.printint32(i32 %2, ptr undef) #9
   ret void
 }
 
@@ -83,7 +84,7 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define linkonce_odr void @"main.closureFunctionGoroutine$1$gowrapper"(ptr %0) unnamed_addr #4 {
+define linkonce_odr void @"main.closureFunctionGoroutine$1$gowrapper"(ptr %0) unnamed_addr #5 {
 entry:
   %1 = load i32, ptr %0, align 4
   %2 = getelementptr inbounds { i32, ptr }, ptr %0, i32 0, i32 1
@@ -92,31 +93,31 @@ entry:
   ret void
 }
 
-declare void @runtime.printint32(i32, ptr) #0
+declare void @runtime.printint32(i32, ptr) #2
 
 ; Function Attrs: nounwind
 define hidden void @main.funcGoroutine(ptr %fn.context, ptr %fn.funcptr, ptr %context) unnamed_addr #1 {
 entry:
-  %0 = call ptr @runtime.alloc(i32 12, ptr null, ptr undef) #8
+  %0 = call dereferenceable(12) ptr @runtime.alloc(i32 12, ptr null, ptr undef) #9
   store i32 5, ptr %0, align 4
   %1 = getelementptr inbounds { i32, ptr, ptr }, ptr %0, i32 0, i32 1
   store ptr %fn.context, ptr %1, align 4
   %2 = getelementptr inbounds { i32, ptr, ptr }, ptr %0, i32 0, i32 2
   store ptr %fn.funcptr, ptr %2, align 4
-  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (ptr @main.funcGoroutine.gowrapper to i32), ptr undef) #8
-  call void @"internal/task.start"(i32 ptrtoint (ptr @main.funcGoroutine.gowrapper to i32), ptr nonnull %0, i32 %stacksize, ptr undef) #8
+  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (ptr @main.funcGoroutine.gowrapper to i32), ptr undef) #9
+  call void @"internal/task.start"(i32 ptrtoint (ptr @main.funcGoroutine.gowrapper to i32), ptr nonnull %0, i32 %stacksize, ptr undef) #9
   ret void
 }
 
 ; Function Attrs: nounwind
-define linkonce_odr void @main.funcGoroutine.gowrapper(ptr %0) unnamed_addr #5 {
+define linkonce_odr void @main.funcGoroutine.gowrapper(ptr %0) unnamed_addr #6 {
 entry:
   %1 = load i32, ptr %0, align 4
   %2 = getelementptr inbounds { i32, ptr, ptr }, ptr %0, i32 0, i32 1
   %3 = load ptr, ptr %2, align 4
   %4 = getelementptr inbounds { i32, ptr, ptr }, ptr %0, i32 0, i32 2
   %5 = load ptr, ptr %4, align 4
-  call void %5(i32 %1, ptr %3) #8
+  call void %5(i32 %1, ptr %3) #9
   ret void
 }
 
@@ -129,59 +130,60 @@ entry:
 ; 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 {
 entry:
-  %copy.n = call i32 @runtime.sliceCopy(ptr %dst.data, ptr %src.data, i32 %dst.len, i32 %src.len, i32 1, ptr undef) #8
+  %copy.n = call i32 @runtime.sliceCopy(ptr %dst.data, ptr %src.data, i32 %dst.len, i32 %src.len, i32 1, ptr undef) #9
   ret void
 }
 
-declare i32 @runtime.sliceCopy(ptr nocapture writeonly, ptr nocapture readonly, i32, i32, i32, ptr) #0
+declare i32 @runtime.sliceCopy(ptr nocapture writeonly, ptr nocapture readonly, i32, i32, i32, ptr) #2
 
 ; Function Attrs: nounwind
 define hidden void @main.closeBuiltinGoroutine(ptr dereferenceable_or_null(32) %ch, ptr %context) unnamed_addr #1 {
 entry:
-  call void @runtime.chanClose(ptr %ch, ptr undef) #8
+  call void @runtime.chanClose(ptr %ch, ptr undef) #9
   ret void
 }
 
-declare void @runtime.chanClose(ptr dereferenceable_or_null(32), ptr) #0
+declare void @runtime.chanClose(ptr dereferenceable_or_null(32), ptr) #2
 
 ; Function Attrs: nounwind
-define hidden void @main.startInterfaceMethod(i32 %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 #1 {
 entry:
-  %0 = call ptr @runtime.alloc(i32 16, ptr null, ptr undef) #8
+  %0 = call dereferenceable(16) ptr @runtime.alloc(i32 16, ptr null, ptr undef) #9
   store ptr %itf.value, ptr %0, align 4
-  %1 = getelementptr inbounds { ptr, %runtime._string, i32 }, ptr %0, i32 0, i32 1
+  %1 = getelementptr inbounds { ptr, %runtime._string, ptr }, ptr %0, i32 0, i32 1
   store ptr @"main$string", ptr %1, align 4
-  %.repack1 = getelementptr inbounds { ptr, %runtime._string, i32 }, ptr %0, i32 0, i32 1, i32 1
+  %.repack1 = getelementptr inbounds { ptr, %runtime._string, ptr }, ptr %0, i32 0, i32 1, i32 1
   store i32 4, ptr %.repack1, align 4
-  %2 = getelementptr inbounds { ptr, %runtime._string, i32 }, ptr %0, i32 0, i32 2
-  store i32 %itf.typecode, ptr %2, align 4
-  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (ptr @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper" to i32), ptr undef) #8
-  call void @"internal/task.start"(i32 ptrtoint (ptr @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper" to i32), ptr nonnull %0, i32 %stacksize, ptr undef) #8
+  %2 = getelementptr inbounds { ptr, %runtime._string, ptr }, ptr %0, i32 0, i32 2
+  store ptr %itf.typecode, ptr %2, align 4
+  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (ptr @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper" to i32), ptr undef) #9
+  call void @"internal/task.start"(i32 ptrtoint (ptr @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper" to i32), ptr nonnull %0, i32 %stacksize, ptr undef) #9
   ret void
 }
 
-declare void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(ptr, ptr, i32, i32, ptr) #6
+declare void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(ptr, ptr, i32, ptr, ptr) #7
 
 ; Function Attrs: nounwind
-define linkonce_odr void @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper"(ptr %0) unnamed_addr #7 {
+define linkonce_odr void @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper"(ptr %0) unnamed_addr #8 {
 entry:
   %1 = load ptr, ptr %0, align 4
-  %2 = getelementptr inbounds { ptr, ptr, i32, i32 }, ptr %0, i32 0, i32 1
+  %2 = getelementptr inbounds { ptr, ptr, i32, ptr }, ptr %0, i32 0, i32 1
   %3 = load ptr, ptr %2, align 4
-  %4 = getelementptr inbounds { ptr, ptr, i32, i32 }, ptr %0, i32 0, i32 2
+  %4 = getelementptr inbounds { ptr, ptr, i32, ptr }, ptr %0, i32 0, i32 2
   %5 = load i32, ptr %4, align 4
-  %6 = getelementptr inbounds { ptr, ptr, i32, i32 }, ptr %0, i32 0, i32 3
-  %7 = load i32, ptr %6, align 4
-  call void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(ptr %1, ptr %3, i32 %5, i32 %7, ptr undef) #8
+  %6 = getelementptr inbounds { ptr, ptr, i32, ptr }, ptr %0, i32 0, i32 3
+  %7 = load ptr, ptr %6, align 4
+  call void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(ptr %1, ptr %3, i32 %5, ptr %7, ptr undef) #9
   ret void
 }
 
-attributes #0 = { "target-features"="+armv7-m,+hwdiv,+soft-float,+strict-align,+thumb-mode,-aes,-bf16,-cdecp0,-cdecp1,-cdecp2,-cdecp3,-cdecp4,-cdecp5,-cdecp6,-cdecp7,-crc,-crypto,-d32,-dotprod,-dsp,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fp64,-fpregs,-fullfp16,-hwdiv-arm,-i8mm,-lob,-mve,-mve.fp,-neon,-pacbti,-ras,-sb,-sha2,-vfp2,-vfp2sp,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp" }
+attributes #0 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+armv7-m,+hwdiv,+soft-float,+strict-align,+thumb-mode,-aes,-bf16,-cdecp0,-cdecp1,-cdecp2,-cdecp3,-cdecp4,-cdecp5,-cdecp6,-cdecp7,-crc,-crypto,-d32,-dotprod,-dsp,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fp64,-fpregs,-fullfp16,-hwdiv-arm,-i8mm,-lob,-mve,-mve.fp,-neon,-pacbti,-ras,-sb,-sha2,-vfp2,-vfp2sp,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp" }
 attributes #1 = { nounwind "target-features"="+armv7-m,+hwdiv,+soft-float,+strict-align,+thumb-mode,-aes,-bf16,-cdecp0,-cdecp1,-cdecp2,-cdecp3,-cdecp4,-cdecp5,-cdecp6,-cdecp7,-crc,-crypto,-d32,-dotprod,-dsp,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fp64,-fpregs,-fullfp16,-hwdiv-arm,-i8mm,-lob,-mve,-mve.fp,-neon,-pacbti,-ras,-sb,-sha2,-vfp2,-vfp2sp,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp" }
-attributes #2 = { nounwind "target-features"="+armv7-m,+hwdiv,+soft-float,+strict-align,+thumb-mode,-aes,-bf16,-cdecp0,-cdecp1,-cdecp2,-cdecp3,-cdecp4,-cdecp5,-cdecp6,-cdecp7,-crc,-crypto,-d32,-dotprod,-dsp,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fp64,-fpregs,-fullfp16,-hwdiv-arm,-i8mm,-lob,-mve,-mve.fp,-neon,-pacbti,-ras,-sb,-sha2,-vfp2,-vfp2sp,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp" "tinygo-gowrapper"="main.regularFunction" }
-attributes #3 = { nounwind "target-features"="+armv7-m,+hwdiv,+soft-float,+strict-align,+thumb-mode,-aes,-bf16,-cdecp0,-cdecp1,-cdecp2,-cdecp3,-cdecp4,-cdecp5,-cdecp6,-cdecp7,-crc,-crypto,-d32,-dotprod,-dsp,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fp64,-fpregs,-fullfp16,-hwdiv-arm,-i8mm,-lob,-mve,-mve.fp,-neon,-pacbti,-ras,-sb,-sha2,-vfp2,-vfp2sp,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp" "tinygo-gowrapper"="main.inlineFunctionGoroutine$1" }
-attributes #4 = { nounwind "target-features"="+armv7-m,+hwdiv,+soft-float,+strict-align,+thumb-mode,-aes,-bf16,-cdecp0,-cdecp1,-cdecp2,-cdecp3,-cdecp4,-cdecp5,-cdecp6,-cdecp7,-crc,-crypto,-d32,-dotprod,-dsp,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fp64,-fpregs,-fullfp16,-hwdiv-arm,-i8mm,-lob,-mve,-mve.fp,-neon,-pacbti,-ras,-sb,-sha2,-vfp2,-vfp2sp,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp" "tinygo-gowrapper"="main.closureFunctionGoroutine$1" }
-attributes #5 = { nounwind "target-features"="+armv7-m,+hwdiv,+soft-float,+strict-align,+thumb-mode,-aes,-bf16,-cdecp0,-cdecp1,-cdecp2,-cdecp3,-cdecp4,-cdecp5,-cdecp6,-cdecp7,-crc,-crypto,-d32,-dotprod,-dsp,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fp64,-fpregs,-fullfp16,-hwdiv-arm,-i8mm,-lob,-mve,-mve.fp,-neon,-pacbti,-ras,-sb,-sha2,-vfp2,-vfp2sp,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp" "tinygo-gowrapper" }
-attributes #6 = { "target-features"="+armv7-m,+hwdiv,+soft-float,+strict-align,+thumb-mode,-aes,-bf16,-cdecp0,-cdecp1,-cdecp2,-cdecp3,-cdecp4,-cdecp5,-cdecp6,-cdecp7,-crc,-crypto,-d32,-dotprod,-dsp,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fp64,-fpregs,-fullfp16,-hwdiv-arm,-i8mm,-lob,-mve,-mve.fp,-neon,-pacbti,-ras,-sb,-sha2,-vfp2,-vfp2sp,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp" "tinygo-invoke"="reflect/methods.Print(string)" "tinygo-methods"="reflect/methods.Print(string)" }
-attributes #7 = { nounwind "target-features"="+armv7-m,+hwdiv,+soft-float,+strict-align,+thumb-mode,-aes,-bf16,-cdecp0,-cdecp1,-cdecp2,-cdecp3,-cdecp4,-cdecp5,-cdecp6,-cdecp7,-crc,-crypto,-d32,-dotprod,-dsp,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fp64,-fpregs,-fullfp16,-hwdiv-arm,-i8mm,-lob,-mve,-mve.fp,-neon,-pacbti,-ras,-sb,-sha2,-vfp2,-vfp2sp,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp" "tinygo-gowrapper"="interface:{Print:func:{basic:string}{}}.Print$invoke" }
-attributes #8 = { nounwind }
+attributes #2 = { "target-features"="+armv7-m,+hwdiv,+soft-float,+strict-align,+thumb-mode,-aes,-bf16,-cdecp0,-cdecp1,-cdecp2,-cdecp3,-cdecp4,-cdecp5,-cdecp6,-cdecp7,-crc,-crypto,-d32,-dotprod,-dsp,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fp64,-fpregs,-fullfp16,-hwdiv-arm,-i8mm,-lob,-mve,-mve.fp,-neon,-pacbti,-ras,-sb,-sha2,-vfp2,-vfp2sp,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp" }
+attributes #3 = { nounwind "target-features"="+armv7-m,+hwdiv,+soft-float,+strict-align,+thumb-mode,-aes,-bf16,-cdecp0,-cdecp1,-cdecp2,-cdecp3,-cdecp4,-cdecp5,-cdecp6,-cdecp7,-crc,-crypto,-d32,-dotprod,-dsp,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fp64,-fpregs,-fullfp16,-hwdiv-arm,-i8mm,-lob,-mve,-mve.fp,-neon,-pacbti,-ras,-sb,-sha2,-vfp2,-vfp2sp,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp" "tinygo-gowrapper"="main.regularFunction" }
+attributes #4 = { nounwind "target-features"="+armv7-m,+hwdiv,+soft-float,+strict-align,+thumb-mode,-aes,-bf16,-cdecp0,-cdecp1,-cdecp2,-cdecp3,-cdecp4,-cdecp5,-cdecp6,-cdecp7,-crc,-crypto,-d32,-dotprod,-dsp,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fp64,-fpregs,-fullfp16,-hwdiv-arm,-i8mm,-lob,-mve,-mve.fp,-neon,-pacbti,-ras,-sb,-sha2,-vfp2,-vfp2sp,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp" "tinygo-gowrapper"="main.inlineFunctionGoroutine$1" }
+attributes #5 = { nounwind "target-features"="+armv7-m,+hwdiv,+soft-float,+strict-align,+thumb-mode,-aes,-bf16,-cdecp0,-cdecp1,-cdecp2,-cdecp3,-cdecp4,-cdecp5,-cdecp6,-cdecp7,-crc,-crypto,-d32,-dotprod,-dsp,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fp64,-fpregs,-fullfp16,-hwdiv-arm,-i8mm,-lob,-mve,-mve.fp,-neon,-pacbti,-ras,-sb,-sha2,-vfp2,-vfp2sp,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp" "tinygo-gowrapper"="main.closureFunctionGoroutine$1" }
+attributes #6 = { nounwind "target-features"="+armv7-m,+hwdiv,+soft-float,+strict-align,+thumb-mode,-aes,-bf16,-cdecp0,-cdecp1,-cdecp2,-cdecp3,-cdecp4,-cdecp5,-cdecp6,-cdecp7,-crc,-crypto,-d32,-dotprod,-dsp,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fp64,-fpregs,-fullfp16,-hwdiv-arm,-i8mm,-lob,-mve,-mve.fp,-neon,-pacbti,-ras,-sb,-sha2,-vfp2,-vfp2sp,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp" "tinygo-gowrapper" }
+attributes #7 = { "target-features"="+armv7-m,+hwdiv,+soft-float,+strict-align,+thumb-mode,-aes,-bf16,-cdecp0,-cdecp1,-cdecp2,-cdecp3,-cdecp4,-cdecp5,-cdecp6,-cdecp7,-crc,-crypto,-d32,-dotprod,-dsp,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fp64,-fpregs,-fullfp16,-hwdiv-arm,-i8mm,-lob,-mve,-mve.fp,-neon,-pacbti,-ras,-sb,-sha2,-vfp2,-vfp2sp,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp" "tinygo-invoke"="reflect/methods.Print(string)" "tinygo-methods"="reflect/methods.Print(string)" }
+attributes #8 = { nounwind "target-features"="+armv7-m,+hwdiv,+soft-float,+strict-align,+thumb-mode,-aes,-bf16,-cdecp0,-cdecp1,-cdecp2,-cdecp3,-cdecp4,-cdecp5,-cdecp6,-cdecp7,-crc,-crypto,-d32,-dotprod,-dsp,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fp64,-fpregs,-fullfp16,-hwdiv-arm,-i8mm,-lob,-mve,-mve.fp,-neon,-pacbti,-ras,-sb,-sha2,-vfp2,-vfp2sp,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp" "tinygo-gowrapper"="interface:{Print:func:{basic:string}{}}.Print$invoke" }
+attributes #9 = { nounwind }

compiler/testdata/goroutine-wasm-asyncify.ll

@@ -7,192 +7,194 @@ 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) #0
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #1
 
 ; Function Attrs: nounwind
-define hidden void @main.init(ptr %context) unnamed_addr #1 {
+define hidden void @main.init(ptr %context) unnamed_addr #2 {
 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 #2 {
 entry:
-  call void @"internal/task.start"(i32 ptrtoint (ptr @"main.regularFunction$gowrapper" to i32), ptr nonnull inttoptr (i32 5 to ptr), i32 16384, ptr undef) #8
+  call void @"internal/task.start"(i32 ptrtoint (ptr @"main.regularFunction$gowrapper" to i32), ptr nonnull inttoptr (i32 5 to ptr), i32 16384, ptr undef) #9
   ret void
 }
 
-declare void @main.regularFunction(i32, ptr) #0
+declare void @main.regularFunction(i32, ptr) #1
 
-declare void @runtime.deadlock(ptr) #0
+declare void @runtime.deadlock(ptr) #1
 
 ; Function Attrs: nounwind
-define linkonce_odr void @"main.regularFunction$gowrapper"(ptr %0) unnamed_addr #2 {
+define linkonce_odr void @"main.regularFunction$gowrapper"(ptr %0) unnamed_addr #3 {
 entry:
   %unpack.int = ptrtoint ptr %0 to i32
-  call void @main.regularFunction(i32 %unpack.int, ptr undef) #8
-  call void @runtime.deadlock(ptr undef) #8
+  call void @main.regularFunction(i32 %unpack.int, ptr undef) #9
+  call void @runtime.deadlock(ptr undef) #9
   unreachable
 }
 
-declare void @"internal/task.start"(i32, ptr, i32, ptr) #0
+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 #2 {
 entry:
-  call void @"internal/task.start"(i32 ptrtoint (ptr @"main.inlineFunctionGoroutine$1$gowrapper" to i32), ptr nonnull inttoptr (i32 5 to ptr), i32 16384, ptr undef) #8
+  call void @"internal/task.start"(i32 ptrtoint (ptr @"main.inlineFunctionGoroutine$1$gowrapper" to i32), ptr nonnull inttoptr (i32 5 to ptr), i32 16384, ptr undef) #9
   ret void
 }
 
 ; 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 #2 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define linkonce_odr void @"main.inlineFunctionGoroutine$1$gowrapper"(ptr %0) unnamed_addr #3 {
+define linkonce_odr void @"main.inlineFunctionGoroutine$1$gowrapper"(ptr %0) unnamed_addr #4 {
 entry:
   %unpack.int = ptrtoint ptr %0 to i32
   call void @"main.inlineFunctionGoroutine$1"(i32 %unpack.int, ptr undef)
-  call void @runtime.deadlock(ptr undef) #8
+  call void @runtime.deadlock(ptr undef) #9
   unreachable
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.closureFunctionGoroutine(ptr %context) unnamed_addr #1 {
+define hidden void @main.closureFunctionGoroutine(ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
-  %n = call ptr @runtime.alloc(i32 4, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #8
-  call void @runtime.trackPointer(ptr nonnull %n, ptr nonnull %stackalloc, ptr undef) #8
+  %n = call dereferenceable(4) ptr @runtime.alloc(i32 4, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #9
+  call void @runtime.trackPointer(ptr nonnull %n, ptr nonnull %stackalloc, ptr undef) #9
   store i32 3, ptr %n, align 4
-  call void @runtime.trackPointer(ptr nonnull %n, ptr nonnull %stackalloc, ptr undef) #8
-  call void @runtime.trackPointer(ptr nonnull @"main.closureFunctionGoroutine$1", ptr nonnull %stackalloc, ptr undef) #8
-  %0 = call ptr @runtime.alloc(i32 8, ptr null, ptr undef) #8
-  call void @runtime.trackPointer(ptr nonnull %0, ptr nonnull %stackalloc, ptr undef) #8
+  call void @runtime.trackPointer(ptr nonnull %n, ptr nonnull %stackalloc, ptr undef) #9
+  call void @runtime.trackPointer(ptr nonnull @"main.closureFunctionGoroutine$1", ptr nonnull %stackalloc, ptr undef) #9
+  %0 = call dereferenceable(8) ptr @runtime.alloc(i32 8, ptr null, ptr undef) #9
+  call void @runtime.trackPointer(ptr nonnull %0, ptr nonnull %stackalloc, ptr undef) #9
   store i32 5, ptr %0, align 4
   %1 = getelementptr inbounds { i32, ptr }, ptr %0, i32 0, i32 1
   store ptr %n, ptr %1, align 4
-  call void @"internal/task.start"(i32 ptrtoint (ptr @"main.closureFunctionGoroutine$1$gowrapper" to i32), ptr nonnull %0, i32 16384, ptr undef) #8
+  call void @"internal/task.start"(i32 ptrtoint (ptr @"main.closureFunctionGoroutine$1$gowrapper" to i32), ptr nonnull %0, i32 16384, ptr undef) #9
   %2 = load i32, ptr %n, align 4
-  call void @runtime.printint32(i32 %2, ptr undef) #8
+  call void @runtime.printint32(i32 %2, ptr undef) #9
   ret void
 }
 
 ; 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 #2 {
 entry:
   store i32 7, ptr %context, align 4
   ret void
 }
 
 ; Function Attrs: nounwind
-define linkonce_odr void @"main.closureFunctionGoroutine$1$gowrapper"(ptr %0) unnamed_addr #4 {
+define linkonce_odr void @"main.closureFunctionGoroutine$1$gowrapper"(ptr %0) unnamed_addr #5 {
 entry:
   %1 = load i32, ptr %0, align 4
   %2 = getelementptr inbounds { i32, ptr }, ptr %0, i32 0, i32 1
   %3 = load ptr, ptr %2, align 4
   call void @"main.closureFunctionGoroutine$1"(i32 %1, ptr %3)
-  call void @runtime.deadlock(ptr undef) #8
+  call void @runtime.deadlock(ptr undef) #9
   unreachable
 }
 
-declare void @runtime.printint32(i32, ptr) #0
+declare void @runtime.printint32(i32, 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 #2 {
 entry:
   %stackalloc = alloca i8, align 1
-  %0 = call ptr @runtime.alloc(i32 12, ptr null, ptr undef) #8
-  call void @runtime.trackPointer(ptr nonnull %0, ptr nonnull %stackalloc, ptr undef) #8
+  %0 = call dereferenceable(12) ptr @runtime.alloc(i32 12, ptr null, ptr undef) #9
+  call void @runtime.trackPointer(ptr nonnull %0, ptr nonnull %stackalloc, ptr undef) #9
   store i32 5, ptr %0, align 4
   %1 = getelementptr inbounds { i32, ptr, ptr }, ptr %0, i32 0, i32 1
   store ptr %fn.context, ptr %1, align 4
   %2 = getelementptr inbounds { i32, ptr, ptr }, ptr %0, i32 0, i32 2
   store ptr %fn.funcptr, ptr %2, align 4
-  call void @"internal/task.start"(i32 ptrtoint (ptr @main.funcGoroutine.gowrapper to i32), ptr nonnull %0, i32 16384, ptr undef) #8
+  call void @"internal/task.start"(i32 ptrtoint (ptr @main.funcGoroutine.gowrapper to i32), ptr nonnull %0, i32 16384, ptr undef) #9
   ret void
 }
 
 ; Function Attrs: nounwind
-define linkonce_odr void @main.funcGoroutine.gowrapper(ptr %0) unnamed_addr #5 {
+define linkonce_odr void @main.funcGoroutine.gowrapper(ptr %0) unnamed_addr #6 {
 entry:
   %1 = load i32, ptr %0, align 4
   %2 = getelementptr inbounds { i32, ptr, ptr }, ptr %0, i32 0, i32 1
   %3 = load ptr, ptr %2, align 4
   %4 = getelementptr inbounds { i32, ptr, ptr }, ptr %0, i32 0, i32 2
   %5 = load ptr, ptr %4, align 4
-  call void %5(i32 %1, ptr %3) #8
-  call void @runtime.deadlock(ptr undef) #8
+  call void %5(i32 %1, ptr %3) #9
+  call void @runtime.deadlock(ptr undef) #9
   unreachable
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.recoverBuiltinGoroutine(ptr %context) unnamed_addr #1 {
+define hidden void @main.recoverBuiltinGoroutine(ptr %context) unnamed_addr #2 {
 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 #2 {
 entry:
-  %copy.n = call i32 @runtime.sliceCopy(ptr %dst.data, ptr %src.data, i32 %dst.len, i32 %src.len, i32 1, ptr undef) #8
+  %copy.n = call i32 @runtime.sliceCopy(ptr %dst.data, ptr %src.data, i32 %dst.len, i32 %src.len, i32 1, ptr undef) #9
   ret void
 }
 
-declare i32 @runtime.sliceCopy(ptr nocapture writeonly, ptr nocapture readonly, i32, i32, i32, ptr) #0
+declare i32 @runtime.sliceCopy(ptr nocapture writeonly, ptr nocapture readonly, i32, i32, i32, ptr) #1
 
 ; Function Attrs: nounwind
-define hidden void @main.closeBuiltinGoroutine(ptr dereferenceable_or_null(32) %ch, ptr %context) unnamed_addr #1 {
+define hidden void @main.closeBuiltinGoroutine(ptr dereferenceable_or_null(32) %ch, ptr %context) unnamed_addr #2 {
 entry:
-  call void @runtime.chanClose(ptr %ch, ptr undef) #8
+  call void @runtime.chanClose(ptr %ch, ptr undef) #9
   ret void
 }
 
-declare void @runtime.chanClose(ptr dereferenceable_or_null(32), ptr) #0
+declare void @runtime.chanClose(ptr dereferenceable_or_null(32), ptr) #1
 
 ; Function Attrs: nounwind
-define hidden void @main.startInterfaceMethod(i32 %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 #2 {
 entry:
   %stackalloc = alloca i8, align 1
-  %0 = call ptr @runtime.alloc(i32 16, ptr null, ptr undef) #8
-  call void @runtime.trackPointer(ptr nonnull %0, ptr nonnull %stackalloc, ptr undef) #8
+  %0 = call dereferenceable(16) ptr @runtime.alloc(i32 16, ptr null, ptr undef) #9
+  call void @runtime.trackPointer(ptr nonnull %0, ptr nonnull %stackalloc, ptr undef) #9
   store ptr %itf.value, ptr %0, align 4
-  %1 = getelementptr inbounds { ptr, %runtime._string, i32 }, ptr %0, i32 0, i32 1
+  %1 = getelementptr inbounds { ptr, %runtime._string, ptr }, ptr %0, i32 0, i32 1
   store ptr @"main$string", ptr %1, align 4
-  %.repack1 = getelementptr inbounds { ptr, %runtime._string, i32 }, ptr %0, i32 0, i32 1, i32 1
+  %.repack1 = getelementptr inbounds { ptr, %runtime._string, ptr }, ptr %0, i32 0, i32 1, i32 1
   store i32 4, ptr %.repack1, align 4
-  %2 = getelementptr inbounds { ptr, %runtime._string, i32 }, ptr %0, i32 0, i32 2
-  store i32 %itf.typecode, ptr %2, align 4
-  call void @"internal/task.start"(i32 ptrtoint (ptr @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper" to i32), ptr nonnull %0, i32 16384, ptr undef) #8
+  %2 = getelementptr inbounds { ptr, %runtime._string, ptr }, ptr %0, i32 0, i32 2
+  store ptr %itf.typecode, ptr %2, align 4
+  call void @"internal/task.start"(i32 ptrtoint (ptr @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper" to i32), ptr nonnull %0, i32 16384, ptr undef) #9
   ret void
 }
 
-declare void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(ptr, ptr, i32, i32, ptr) #6
+declare void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(ptr, ptr, i32, ptr, ptr) #7
 
 ; Function Attrs: nounwind
-define linkonce_odr void @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper"(ptr %0) unnamed_addr #7 {
+define linkonce_odr void @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper"(ptr %0) unnamed_addr #8 {
 entry:
   %1 = load ptr, ptr %0, align 4
-  %2 = getelementptr inbounds { ptr, ptr, i32, i32 }, ptr %0, i32 0, i32 1
+  %2 = getelementptr inbounds { ptr, ptr, i32, ptr }, ptr %0, i32 0, i32 1
   %3 = load ptr, ptr %2, align 4
-  %4 = getelementptr inbounds { ptr, ptr, i32, i32 }, ptr %0, i32 0, i32 2
+  %4 = getelementptr inbounds { ptr, ptr, i32, ptr }, ptr %0, i32 0, i32 2
   %5 = load i32, ptr %4, align 4
-  %6 = getelementptr inbounds { ptr, ptr, i32, i32 }, ptr %0, i32 0, i32 3
-  %7 = load i32, ptr %6, align 4
-  call void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(ptr %1, ptr %3, i32 %5, i32 %7, ptr undef) #8
-  call void @runtime.deadlock(ptr undef) #8
+  %6 = getelementptr inbounds { ptr, ptr, i32, ptr }, ptr %0, i32 0, i32 3
+  %7 = load ptr, ptr %6, align 4
+  call void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(ptr %1, ptr %3, i32 %5, ptr %7, ptr undef) #9
+  call void @runtime.deadlock(ptr undef) #9
   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 "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "tinygo-gowrapper"="main.regularFunction" }
-attributes #3 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "tinygo-gowrapper"="main.inlineFunctionGoroutine$1" }
-attributes #4 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "tinygo-gowrapper"="main.closureFunctionGoroutine$1" }
-attributes #5 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "tinygo-gowrapper" }
-attributes #6 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "tinygo-invoke"="reflect/methods.Print(string)" "tinygo-methods"="reflect/methods.Print(string)" }
-attributes #7 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "tinygo-gowrapper"="interface:{Print:func:{basic:string}{}}.Print$invoke" }
-attributes #8 = { nounwind }
+attributes #0 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #1 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #2 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #3 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "tinygo-gowrapper"="main.regularFunction" }
+attributes #4 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "tinygo-gowrapper"="main.inlineFunctionGoroutine$1" }
+attributes #5 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "tinygo-gowrapper"="main.closureFunctionGoroutine$1" }
+attributes #6 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "tinygo-gowrapper" }
+attributes #7 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "tinygo-invoke"="reflect/methods.Print(string)" "tinygo-methods"="reflect/methods.Print(string)" }
+attributes #8 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "tinygo-gowrapper"="interface:{Print:func:{basic:string}{}}.Print$invoke" }
+attributes #9 = { nounwind }

compiler/testdata/interface.ll

@@ -3,74 +3,71 @@ source_filename = "interface.go"
 target datalayout = "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-n32:64-S128-ni:1:10:20"
 target triple = "wasm32-unknown-wasi"
 
-%runtime.typecodeID = type { ptr, i32, ptr, ptr, i32 }
-%runtime._interface = type { i32, ptr }
+%runtime._interface = type { ptr, ptr }
 %runtime._string = type { ptr, i32 }
 
-@"reflect/types.type:basic:int" = linkonce_odr constant %runtime.typecodeID { ptr null, i32 0, ptr null, ptr @"reflect/types.type:pointer:basic:int", i32 0 }
-@"reflect/types.type:pointer:basic:int" = linkonce_odr constant %runtime.typecodeID { ptr @"reflect/types.type:basic:int", i32 0, ptr null, ptr null, i32 0 }
-@"reflect/types.type:pointer:named:error" = linkonce_odr constant %runtime.typecodeID { ptr @"reflect/types.type:named:error", i32 0, ptr null, ptr null, i32 0 }
-@"reflect/types.type:named:error" = linkonce_odr constant %runtime.typecodeID { ptr @"reflect/types.type:interface:{Error:func:{}{basic:string}}", i32 0, ptr null, ptr @"reflect/types.type:pointer:named:error", i32 ptrtoint (ptr @"interface:{Error:func:{}{basic:string}}.$typeassert" to i32) }
-@"reflect/types.type:interface:{Error:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { ptr @"reflect/types.interface:interface{Error() string}$interface", i32 0, ptr null, ptr @"reflect/types.type:pointer:interface:{Error:func:{}{basic:string}}", i32 ptrtoint (ptr @"interface:{Error:func:{}{basic:string}}.$typeassert" to i32) }
-@"reflect/methods.Error() string" = linkonce_odr constant i8 0, align 1
-@"reflect/types.interface:interface{Error() string}$interface" = linkonce_odr constant [1 x ptr] [ptr @"reflect/methods.Error() string"]
-@"reflect/types.type:pointer:interface:{Error:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { ptr @"reflect/types.type:interface:{Error:func:{}{basic:string}}", i32 0, ptr null, ptr null, i32 0 }
-@"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { ptr @"reflect/types.type:interface:{String:func:{}{basic:string}}", i32 0, ptr null, ptr null, i32 0 }
-@"reflect/types.type:interface:{String:func:{}{basic:string}}" = linkonce_odr constant %runtime.typecodeID { ptr @"reflect/types.interface:interface{String() string}$interface", i32 0, ptr null, ptr @"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}", i32 ptrtoint (ptr @"interface:{String:func:{}{basic:string}}.$typeassert" to i32) }
-@"reflect/methods.String() string" = linkonce_odr constant i8 0, align 1
-@"reflect/types.interface:interface{String() string}$interface" = linkonce_odr constant [1 x ptr] [ptr @"reflect/methods.String() string"]
+@"reflect/types.type:basic:int" = linkonce_odr constant { i8, ptr } { i8 2, ptr @"reflect/types.type:pointer:basic:int" }, align 4
+@"reflect/types.type:pointer:basic:int" = linkonce_odr constant { i8, i16, ptr } { i8 21, i16 0, ptr @"reflect/types.type:basic:int" }, align 4
+@"reflect/types.type:pointer:named:error" = linkonce_odr constant { i8, i16, ptr } { i8 21, 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 52, 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.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 20, ptr @"reflect/types.type:pointer:interface:{Error:func:{}{basic:string}}" }, align 4
+@"reflect/types.type:pointer:interface:{Error:func:{}{basic:string}}" = linkonce_odr constant { i8, i16, ptr } { i8 21, 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 21, 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 20, ptr @"reflect/types.type:pointer:interface:{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) #0
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #1
 
 ; Function Attrs: nounwind
-define hidden void @main.init(ptr %context) unnamed_addr #1 {
+define hidden void @main.init(ptr %context) unnamed_addr #2 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden %runtime._interface @main.simpleType(ptr %context) unnamed_addr #1 {
+define hidden %runtime._interface @main.simpleType(ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
-  call void @runtime.trackPointer(ptr null, ptr nonnull %stackalloc, ptr undef) #6
-  ret %runtime._interface { i32 ptrtoint (ptr @"reflect/types.type:basic:int" to i32), ptr null }
+  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
+  ret %runtime._interface { ptr @"reflect/types.type:basic:int", ptr null }
 }
 
 ; Function Attrs: nounwind
-define hidden %runtime._interface @main.pointerType(ptr %context) unnamed_addr #1 {
+define hidden %runtime._interface @main.pointerType(ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
-  call void @runtime.trackPointer(ptr null, ptr nonnull %stackalloc, ptr undef) #6
-  ret %runtime._interface { i32 ptrtoint (ptr @"reflect/types.type:pointer:basic:int" to i32), ptr null }
+  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
+  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 #1 {
+define hidden %runtime._interface @main.interfaceType(ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
-  call void @runtime.trackPointer(ptr null, ptr nonnull %stackalloc, ptr undef) #6
-  ret %runtime._interface { i32 ptrtoint (ptr @"reflect/types.type:pointer:named:error" to i32), ptr null }
+  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
+  ret %runtime._interface { ptr @"reflect/types.type:pointer:named:error", ptr null }
 }
 
-declare i1 @"interface:{Error:func:{}{basic:string}}.$typeassert"(i32) #2
-
 ; Function Attrs: nounwind
-define hidden %runtime._interface @main.anonymousInterfaceType(ptr %context) unnamed_addr #1 {
+define hidden %runtime._interface @main.anonymousInterfaceType(ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
-  call void @runtime.trackPointer(ptr null, ptr nonnull %stackalloc, ptr undef) #6
-  ret %runtime._interface { i32 ptrtoint (ptr @"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}" to i32), ptr null }
+  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
+  ret %runtime._interface { ptr @"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}", ptr null }
 }
 
-declare i1 @"interface:{String:func:{}{basic:string}}.$typeassert"(i32) #3
-
 ; Function Attrs: nounwind
-define hidden i1 @main.isInt(i32 %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
+define hidden i1 @main.isInt(ptr %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #2 {
 entry:
-  %typecode = call i1 @runtime.typeAssert(i32 %itf.typecode, ptr nonnull @"reflect/types.typeid:basic:int", ptr undef) #6
+  %typecode = call i1 @runtime.typeAssert(ptr %itf.typecode, ptr nonnull @"reflect/types.typeid:basic:int", ptr undef) #7
   br i1 %typecode, label %typeassert.ok, label %typeassert.next
 
 typeassert.next:                                  ; preds = %typeassert.ok, %entry
@@ -80,12 +77,12 @@ typeassert.ok:                                    ; preds = %entry
   br label %typeassert.next
 }
 
-declare i1 @runtime.typeAssert(i32, ptr dereferenceable_or_null(1), ptr) #0
+declare i1 @runtime.typeAssert(ptr, ptr dereferenceable_or_null(1), ptr) #1
 
 ; Function Attrs: nounwind
-define hidden i1 @main.isError(i32 %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
+define hidden i1 @main.isError(ptr %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #2 {
 entry:
-  %0 = call i1 @"interface:{Error:func:{}{basic:string}}.$typeassert"(i32 %itf.typecode) #6
+  %0 = call i1 @"interface:{Error:func:{}{basic:string}}.$typeassert"(ptr %itf.typecode) #7
   br i1 %0, label %typeassert.ok, label %typeassert.next
 
 typeassert.next:                                  ; preds = %typeassert.ok, %entry
@@ -95,10 +92,12 @@ typeassert.ok:                                    ; preds = %entry
   br label %typeassert.next
 }
 
+declare i1 @"interface:{Error:func:{}{basic:string}}.$typeassert"(ptr) #3
+
 ; Function Attrs: nounwind
-define hidden i1 @main.isStringer(i32 %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
+define hidden i1 @main.isStringer(ptr %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #2 {
 entry:
-  %0 = call i1 @"interface:{String:func:{}{basic:string}}.$typeassert"(i32 %itf.typecode) #6
+  %0 = call i1 @"interface:{String:func:{}{basic:string}}.$typeassert"(ptr %itf.typecode) #7
   br i1 %0, label %typeassert.ok, label %typeassert.next
 
 typeassert.next:                                  ; preds = %typeassert.ok, %entry
@@ -108,31 +107,34 @@ typeassert.ok:                                    ; preds = %entry
   br label %typeassert.next
 }
 
+declare i1 @"interface:{String:func:{}{basic:string}}.$typeassert"(ptr) #4
+
 ; Function Attrs: nounwind
-define hidden i8 @main.callFooMethod(i32 %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
+define hidden i8 @main.callFooMethod(ptr %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #2 {
 entry:
-  %0 = call i8 @"interface:{String:func:{}{basic:string},main.foo:func:{basic:int}{basic:uint8}}.foo$invoke"(ptr %itf.value, i32 3, i32 %itf.typecode, ptr undef) #6
+  %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
   ret i8 %0
 }
 
-declare i8 @"interface:{String:func:{}{basic:string},main.foo:func:{basic:int}{basic:uint8}}.foo$invoke"(ptr, i32, i32, ptr) #4
+declare i8 @"interface:{String:func:{}{basic:string},main.foo:func:{basic:int}{basic:uint8}}.foo$invoke"(ptr, i32, ptr, ptr) #5
 
 ; Function Attrs: nounwind
-define hidden %runtime._string @main.callErrorMethod(i32 %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
+define hidden %runtime._string @main.callErrorMethod(ptr %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
-  %0 = call %runtime._string @"interface:{Error:func:{}{basic:string}}.Error$invoke"(ptr %itf.value, i32 %itf.typecode, ptr undef) #6
+  %0 = call %runtime._string @"interface:{Error:func:{}{basic:string}}.Error$invoke"(ptr %itf.value, ptr %itf.typecode, ptr undef) #7
   %1 = extractvalue %runtime._string %0, 0
-  call void @runtime.trackPointer(ptr %1, ptr nonnull %stackalloc, ptr undef) #6
+  call void @runtime.trackPointer(ptr %1, ptr nonnull %stackalloc, ptr undef) #7
   ret %runtime._string %0
 }
 
-declare %runtime._string @"interface:{Error:func:{}{basic:string}}.Error$invoke"(ptr, i32, ptr) #5
+declare %runtime._string @"interface:{Error:func:{}{basic:string}}.Error$invoke"(ptr, ptr, ptr) #6
 
-attributes #0 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
-attributes #1 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
-attributes #2 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "tinygo-methods"="reflect/methods.Error() string" }
-attributes #3 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "tinygo-methods"="reflect/methods.String() string" }
-attributes #4 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "tinygo-invoke"="main.$methods.foo(int) uint8" "tinygo-methods"="reflect/methods.String() string; main.$methods.foo(int) uint8" }
-attributes #5 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "tinygo-invoke"="reflect/methods.Error() string" "tinygo-methods"="reflect/methods.Error() string" }
-attributes #6 = { nounwind }
+attributes #0 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #1 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #2 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #3 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "tinygo-methods"="reflect/methods.Error() string" }
+attributes #4 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "tinygo-methods"="reflect/methods.String() string" }
+attributes #5 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "tinygo-invoke"="main.$methods.foo(int) uint8" "tinygo-methods"="reflect/methods.String() string; main.$methods.foo(int) uint8" }
+attributes #6 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "tinygo-invoke"="reflect/methods.Error() string" "tinygo-methods"="reflect/methods.Error() string" }
+attributes #7 = { nounwind }

compiler/testdata/pointer.go

@@ -24,18 +24,3 @@ func pointerCastToUnsafe(x *int) unsafe.Pointer {
 func pointerCastToUnsafeNoop(x *byte) unsafe.Pointer {
 	return unsafe.Pointer(x)
 }
-
-// The compiler has support for a few special cast+add patterns that are
-// transformed into a single GEP.
-
-func pointerUnsafeGEPFixedOffset(ptr *byte) *byte {
-	return (*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ptr)) + 10))
-}
-
-func pointerUnsafeGEPByteOffset(ptr *byte, offset uintptr) *byte {
-	return (*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(ptr)) + offset))
-}
-
-func pointerUnsafeGEPIntOffset(ptr *int32, offset uintptr) *int32 {
-	return (*int32)(unsafe.Pointer(uintptr(unsafe.Pointer(ptr)) + offset*4))
-}

compiler/testdata/pointer.ll

@@ -3,80 +3,48 @@ source_filename = "pointer.go"
 target datalayout = "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-n32:64-S128-ni:1:10:20"
 target triple = "wasm32-unknown-wasi"
 
+; 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) #0
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #1
 
 ; Function Attrs: nounwind
-define hidden void @main.init(ptr %context) unnamed_addr #1 {
+define hidden void @main.init(ptr %context) unnamed_addr #2 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden [0 x i32] @main.pointerDerefZero(ptr %x, ptr %context) unnamed_addr #1 {
+define hidden [0 x i32] @main.pointerDerefZero(ptr %x, ptr %context) unnamed_addr #2 {
 entry:
   ret [0 x i32] zeroinitializer
 }
 
 ; Function Attrs: nounwind
-define hidden ptr @main.pointerCastFromUnsafe(ptr %x, ptr %context) unnamed_addr #1 {
+define hidden ptr @main.pointerCastFromUnsafe(ptr %x, ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
-  call void @runtime.trackPointer(ptr %x, ptr nonnull %stackalloc, ptr undef) #2
+  call void @runtime.trackPointer(ptr %x, ptr nonnull %stackalloc, ptr undef) #3
   ret ptr %x
 }
 
 ; Function Attrs: nounwind
-define hidden ptr @main.pointerCastToUnsafe(ptr dereferenceable_or_null(4) %x, ptr %context) unnamed_addr #1 {
+define hidden ptr @main.pointerCastToUnsafe(ptr dereferenceable_or_null(4) %x, ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
-  call void @runtime.trackPointer(ptr %x, ptr nonnull %stackalloc, ptr undef) #2
+  call void @runtime.trackPointer(ptr %x, ptr nonnull %stackalloc, ptr undef) #3
   ret ptr %x
 }
 
 ; Function Attrs: nounwind
-define hidden ptr @main.pointerCastToUnsafeNoop(ptr dereferenceable_or_null(1) %x, ptr %context) unnamed_addr #1 {
+define hidden ptr @main.pointerCastToUnsafeNoop(ptr dereferenceable_or_null(1) %x, ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
-  call void @runtime.trackPointer(ptr %x, ptr nonnull %stackalloc, ptr undef) #2
+  call void @runtime.trackPointer(ptr %x, ptr nonnull %stackalloc, ptr undef) #3
   ret ptr %x
 }
 
-; Function Attrs: nounwind
-define hidden ptr @main.pointerUnsafeGEPFixedOffset(ptr dereferenceable_or_null(1) %ptr, ptr %context) unnamed_addr #1 {
-entry:
-  %stackalloc = alloca i8, align 1
-  call void @runtime.trackPointer(ptr %ptr, ptr nonnull %stackalloc, ptr undef) #2
-  %0 = getelementptr inbounds i8, ptr %ptr, i32 10
-  call void @runtime.trackPointer(ptr nonnull %0, ptr nonnull %stackalloc, ptr undef) #2
-  call void @runtime.trackPointer(ptr nonnull %0, ptr nonnull %stackalloc, ptr undef) #2
-  ret ptr %0
-}
-
-; Function Attrs: nounwind
-define hidden ptr @main.pointerUnsafeGEPByteOffset(ptr dereferenceable_or_null(1) %ptr, i32 %offset, ptr %context) unnamed_addr #1 {
-entry:
-  %stackalloc = alloca i8, align 1
-  call void @runtime.trackPointer(ptr %ptr, ptr nonnull %stackalloc, ptr undef) #2
-  %0 = getelementptr inbounds i8, ptr %ptr, i32 %offset
-  call void @runtime.trackPointer(ptr %0, ptr nonnull %stackalloc, ptr undef) #2
-  call void @runtime.trackPointer(ptr %0, ptr nonnull %stackalloc, ptr undef) #2
-  ret ptr %0
-}
-
-; Function Attrs: nounwind
-define hidden ptr @main.pointerUnsafeGEPIntOffset(ptr dereferenceable_or_null(4) %ptr, i32 %offset, ptr %context) unnamed_addr #1 {
-entry:
-  %stackalloc = alloca i8, align 1
-  call void @runtime.trackPointer(ptr %ptr, ptr nonnull %stackalloc, ptr undef) #2
-  %0 = shl i32 %offset, 2
-  %1 = getelementptr inbounds i8, ptr %ptr, i32 %0
-  call void @runtime.trackPointer(ptr %1, ptr nonnull %stackalloc, ptr undef) #2
-  call void @runtime.trackPointer(ptr %1, ptr nonnull %stackalloc, ptr undef) #2
-  ret ptr %1
-}
-
-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 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #1 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #2 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #3 = { nounwind }

compiler/testdata/pragma.go

@@ -59,6 +59,13 @@ func functionInSection() {
 func exportedFunctionInSection() {
 }
 
+//go:wasmimport modulename import1
+func declaredImport()
+
+//go:wasmimport modulename import2
+func definedImport() {
+}
+
 // This function should not: it's only a declaration and not a definition.
 //
 //go:section .special_function_section

compiler/testdata/pragma.ll

@@ -11,59 +11,70 @@ 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) #0
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #1
 
 ; Function Attrs: nounwind
-define hidden void @main.init(ptr %context) unnamed_addr #1 {
+define hidden void @main.init(ptr %context) unnamed_addr #2 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define void @extern_func() #2 {
+define void @extern_func() #3 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @somepkg.someFunction1(ptr %context) unnamed_addr #1 {
+define hidden void @somepkg.someFunction1(ptr %context) unnamed_addr #2 {
 entry:
   ret void
 }
 
-declare void @somepkg.someFunction2(ptr) #0
+declare void @somepkg.someFunction2(ptr) #1
 
 ; Function Attrs: inlinehint nounwind
-define hidden void @main.inlineFunc(ptr %context) unnamed_addr #3 {
+define hidden void @main.inlineFunc(ptr %context) unnamed_addr #4 {
 entry:
   ret void
 }
 
 ; Function Attrs: noinline nounwind
-define hidden void @main.noinlineFunc(ptr %context) unnamed_addr #4 {
+define hidden void @main.noinlineFunc(ptr %context) unnamed_addr #5 {
 entry:
   ret void
 }
 
+; Function Attrs: noinline nounwind
+define hidden void @main.functionInSection(ptr %context) unnamed_addr #5 section ".special_function_section" {
+entry:
+  ret void
+}
+
+; Function Attrs: noinline nounwind
+define void @exportedFunctionInSection() #6 section ".special_function_section" {
+entry:
+  ret void
+}
+
+declare void @main.declaredImport() #7
+
 ; Function Attrs: nounwind
-define hidden void @main.functionInSection(ptr %context) unnamed_addr #1 section ".special_function_section" {
+define hidden void @main.definedImport(ptr %context) unnamed_addr #2 {
 entry:
   ret void
 }
 
-; Function Attrs: nounwind
-define void @exportedFunctionInSection() #5 section ".special_function_section" {
-entry:
-  ret void
-}
+declare void @main.undefinedFunctionNotInSection(ptr) #1
 
-declare void @main.undefinedFunctionNotInSection(ptr) #0
-
-attributes #0 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
-attributes #1 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
-attributes #2 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "wasm-export-name"="extern_func" "wasm-import-module"="env" "wasm-import-name"="extern_func" }
-attributes #3 = { inlinehint nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
-attributes #4 = { noinline nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
-attributes #5 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "wasm-export-name"="exportedFunctionInSection" "wasm-import-module"="env" "wasm-import-name"="exportedFunctionInSection" }
+attributes #0 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #1 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #2 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #3 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "wasm-export-name"="extern_func" "wasm-import-module"="env" "wasm-import-name"="extern_func" }
+attributes #4 = { inlinehint nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #5 = { noinline nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #6 = { noinline nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "wasm-export-name"="exportedFunctionInSection" "wasm-import-module"="env" "wasm-import-name"="exportedFunctionInSection" }
+attributes #7 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" "wasm-import-module"="modulename" "wasm-import-name"="import1" }

compiler/testdata/slice.ll

@@ -3,30 +3,31 @@ source_filename = "slice.go"
 target datalayout = "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-n32:64-S128-ni:1:10:20"
 target triple = "wasm32-unknown-wasi"
 
+; 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) #0
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #1
 
 ; Function Attrs: nounwind
-define hidden void @main.init(ptr %context) unnamed_addr #1 {
+define hidden void @main.init(ptr %context) unnamed_addr #2 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.sliceLen(ptr %ints.data, i32 %ints.len, i32 %ints.cap, ptr %context) unnamed_addr #1 {
+define hidden i32 @main.sliceLen(ptr %ints.data, i32 %ints.len, i32 %ints.cap, ptr %context) unnamed_addr #2 {
 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 #1 {
+define hidden i32 @main.sliceCap(ptr %ints.data, i32 %ints.len, i32 %ints.cap, ptr %context) unnamed_addr #2 {
 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 #1 {
+define hidden i32 @main.sliceElement(ptr %ints.data, i32 %ints.len, i32 %ints.cap, i32 %index, ptr %context) unnamed_addr #2 {
 entry:
   %.not = icmp ult i32 %index, %ints.len
   br i1 %.not, label %lookup.next, label %lookup.throw
@@ -37,84 +38,84 @@ lookup.next:                                      ; preds = %entry
   ret i32 %1
 
 lookup.throw:                                     ; preds = %entry
-  call void @runtime.lookupPanic(ptr undef) #2
+  call void @runtime.lookupPanic(ptr undef) #3
   unreachable
 }
 
-declare void @runtime.lookupPanic(ptr) #0
+declare void @runtime.lookupPanic(ptr) #1
 
 ; Function Attrs: nounwind
-define hidden { ptr, i32, i32 } @main.sliceAppendValues(ptr %ints.data, i32 %ints.len, i32 %ints.cap, ptr %context) unnamed_addr #1 {
+define hidden { ptr, i32, i32 } @main.sliceAppendValues(ptr %ints.data, i32 %ints.len, i32 %ints.cap, ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
-  %varargs = call ptr @runtime.alloc(i32 12, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #2
-  call void @runtime.trackPointer(ptr nonnull %varargs, ptr nonnull %stackalloc, ptr undef) #2
+  %varargs = call dereferenceable(12) ptr @runtime.alloc(i32 12, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
+  call void @runtime.trackPointer(ptr nonnull %varargs, ptr nonnull %stackalloc, ptr undef) #3
   store i32 1, ptr %varargs, align 4
   %0 = getelementptr inbounds [3 x i32], ptr %varargs, i32 0, i32 1
   store i32 2, ptr %0, align 4
   %1 = getelementptr inbounds [3 x i32], ptr %varargs, i32 0, i32 2
   store i32 3, ptr %1, align 4
-  %append.new = call { ptr, i32, i32 } @runtime.sliceAppend(ptr %ints.data, ptr nonnull %varargs, i32 %ints.len, i32 %ints.cap, i32 3, i32 4, ptr undef) #2
+  %append.new = call { ptr, i32, i32 } @runtime.sliceAppend(ptr %ints.data, ptr nonnull %varargs, i32 %ints.len, i32 %ints.cap, i32 3, i32 4, ptr undef) #3
   %append.newPtr = extractvalue { ptr, i32, i32 } %append.new, 0
   %append.newLen = extractvalue { ptr, i32, i32 } %append.new, 1
   %append.newCap = extractvalue { ptr, i32, i32 } %append.new, 2
   %2 = insertvalue { ptr, i32, i32 } undef, ptr %append.newPtr, 0
   %3 = insertvalue { ptr, i32, i32 } %2, i32 %append.newLen, 1
   %4 = insertvalue { ptr, i32, i32 } %3, i32 %append.newCap, 2
-  call void @runtime.trackPointer(ptr %append.newPtr, ptr nonnull %stackalloc, ptr undef) #2
+  call void @runtime.trackPointer(ptr %append.newPtr, ptr nonnull %stackalloc, ptr undef) #3
   ret { ptr, i32, i32 } %4
 }
 
-declare { ptr, i32, i32 } @runtime.sliceAppend(ptr, ptr nocapture readonly, i32, i32, i32, i32, ptr) #0
+declare { ptr, i32, i32 } @runtime.sliceAppend(ptr, ptr nocapture readonly, i32, i32, i32, i32, ptr) #1
 
 ; 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 #1 {
+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 {
 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 undef) #2
+  %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 undef) #3
   %append.newPtr = extractvalue { ptr, i32, i32 } %append.new, 0
   %append.newLen = extractvalue { ptr, i32, i32 } %append.new, 1
   %append.newCap = extractvalue { ptr, i32, i32 } %append.new, 2
   %0 = insertvalue { ptr, i32, i32 } undef, ptr %append.newPtr, 0
   %1 = insertvalue { ptr, i32, i32 } %0, i32 %append.newLen, 1
   %2 = insertvalue { ptr, i32, i32 } %1, i32 %append.newCap, 2
-  call void @runtime.trackPointer(ptr %append.newPtr, ptr nonnull %stackalloc, ptr undef) #2
+  call void @runtime.trackPointer(ptr %append.newPtr, ptr nonnull %stackalloc, ptr undef) #3
   ret { ptr, i32, i32 } %2
 }
 
 ; 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 #1 {
+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 {
 entry:
-  %copy.n = call i32 @runtime.sliceCopy(ptr %dst.data, ptr %src.data, i32 %dst.len, i32 %src.len, i32 4, ptr undef) #2
+  %copy.n = call i32 @runtime.sliceCopy(ptr %dst.data, ptr %src.data, i32 %dst.len, i32 %src.len, i32 4, ptr undef) #3
   ret i32 %copy.n
 }
 
-declare i32 @runtime.sliceCopy(ptr nocapture writeonly, ptr nocapture readonly, i32, i32, i32, ptr) #0
+declare i32 @runtime.sliceCopy(ptr nocapture writeonly, ptr nocapture readonly, i32, i32, i32, ptr) #1
 
 ; Function Attrs: nounwind
-define hidden { ptr, i32, i32 } @main.makeByteSlice(i32 %len, ptr %context) unnamed_addr #1 {
+define hidden { ptr, i32, i32 } @main.makeByteSlice(i32 %len, ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
   %slice.maxcap = icmp slt i32 %len, 0
   br i1 %slice.maxcap, label %slice.throw, label %slice.next
 
 slice.next:                                       ; preds = %entry
-  %makeslice.buf = call ptr @runtime.alloc(i32 %len, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #2
+  %makeslice.buf = call ptr @runtime.alloc(i32 %len, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
   %0 = insertvalue { ptr, i32, i32 } undef, ptr %makeslice.buf, 0
   %1 = insertvalue { ptr, i32, i32 } %0, i32 %len, 1
   %2 = insertvalue { ptr, i32, i32 } %1, i32 %len, 2
-  call void @runtime.trackPointer(ptr nonnull %makeslice.buf, ptr nonnull %stackalloc, ptr undef) #2
+  call void @runtime.trackPointer(ptr nonnull %makeslice.buf, ptr nonnull %stackalloc, ptr undef) #3
   ret { ptr, i32, i32 } %2
 
 slice.throw:                                      ; preds = %entry
-  call void @runtime.slicePanic(ptr undef) #2
+  call void @runtime.slicePanic(ptr undef) #3
   unreachable
 }
 
-declare void @runtime.slicePanic(ptr) #0
+declare void @runtime.slicePanic(ptr) #1
 
 ; Function Attrs: nounwind
-define hidden { ptr, i32, i32 } @main.makeInt16Slice(i32 %len, ptr %context) unnamed_addr #1 {
+define hidden { ptr, i32, i32 } @main.makeInt16Slice(i32 %len, ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
   %slice.maxcap = icmp slt i32 %len, 0
@@ -122,20 +123,20 @@ entry:
 
 slice.next:                                       ; preds = %entry
   %makeslice.cap = shl i32 %len, 1
-  %makeslice.buf = call ptr @runtime.alloc(i32 %makeslice.cap, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #2
+  %makeslice.buf = call ptr @runtime.alloc(i32 %makeslice.cap, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
   %0 = insertvalue { ptr, i32, i32 } undef, ptr %makeslice.buf, 0
   %1 = insertvalue { ptr, i32, i32 } %0, i32 %len, 1
   %2 = insertvalue { ptr, i32, i32 } %1, i32 %len, 2
-  call void @runtime.trackPointer(ptr nonnull %makeslice.buf, ptr nonnull %stackalloc, ptr undef) #2
+  call void @runtime.trackPointer(ptr nonnull %makeslice.buf, ptr nonnull %stackalloc, ptr undef) #3
   ret { ptr, i32, i32 } %2
 
 slice.throw:                                      ; preds = %entry
-  call void @runtime.slicePanic(ptr undef) #2
+  call void @runtime.slicePanic(ptr undef) #3
   unreachable
 }
 
 ; Function Attrs: nounwind
-define hidden { ptr, i32, i32 } @main.makeArraySlice(i32 %len, ptr %context) unnamed_addr #1 {
+define hidden { ptr, i32, i32 } @main.makeArraySlice(i32 %len, ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
   %slice.maxcap = icmp ugt i32 %len, 1431655765
@@ -143,20 +144,20 @@ entry:
 
 slice.next:                                       ; preds = %entry
   %makeslice.cap = mul i32 %len, 3
-  %makeslice.buf = call ptr @runtime.alloc(i32 %makeslice.cap, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #2
+  %makeslice.buf = call ptr @runtime.alloc(i32 %makeslice.cap, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
   %0 = insertvalue { ptr, i32, i32 } undef, ptr %makeslice.buf, 0
   %1 = insertvalue { ptr, i32, i32 } %0, i32 %len, 1
   %2 = insertvalue { ptr, i32, i32 } %1, i32 %len, 2
-  call void @runtime.trackPointer(ptr nonnull %makeslice.buf, ptr nonnull %stackalloc, ptr undef) #2
+  call void @runtime.trackPointer(ptr nonnull %makeslice.buf, ptr nonnull %stackalloc, ptr undef) #3
   ret { ptr, i32, i32 } %2
 
 slice.throw:                                      ; preds = %entry
-  call void @runtime.slicePanic(ptr undef) #2
+  call void @runtime.slicePanic(ptr undef) #3
   unreachable
 }
 
 ; Function Attrs: nounwind
-define hidden { ptr, i32, i32 } @main.makeInt32Slice(i32 %len, ptr %context) unnamed_addr #1 {
+define hidden { ptr, i32, i32 } @main.makeInt32Slice(i32 %len, ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
   %slice.maxcap = icmp ugt i32 %len, 1073741823
@@ -164,39 +165,39 @@ entry:
 
 slice.next:                                       ; preds = %entry
   %makeslice.cap = shl i32 %len, 2
-  %makeslice.buf = call ptr @runtime.alloc(i32 %makeslice.cap, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #2
+  %makeslice.buf = call ptr @runtime.alloc(i32 %makeslice.cap, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
   %0 = insertvalue { ptr, i32, i32 } undef, ptr %makeslice.buf, 0
   %1 = insertvalue { ptr, i32, i32 } %0, i32 %len, 1
   %2 = insertvalue { ptr, i32, i32 } %1, i32 %len, 2
-  call void @runtime.trackPointer(ptr nonnull %makeslice.buf, ptr nonnull %stackalloc, ptr undef) #2
+  call void @runtime.trackPointer(ptr nonnull %makeslice.buf, ptr nonnull %stackalloc, ptr undef) #3
   ret { ptr, i32, i32 } %2
 
 slice.throw:                                      ; preds = %entry
-  call void @runtime.slicePanic(ptr undef) #2
+  call void @runtime.slicePanic(ptr undef) #3
   unreachable
 }
 
 ; Function Attrs: nounwind
-define hidden ptr @main.Add32(ptr %p, i32 %len, ptr %context) unnamed_addr #1 {
+define hidden ptr @main.Add32(ptr %p, i32 %len, ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
   %0 = getelementptr i8, ptr %p, i32 %len
-  call void @runtime.trackPointer(ptr %0, ptr nonnull %stackalloc, ptr undef) #2
+  call void @runtime.trackPointer(ptr %0, ptr nonnull %stackalloc, ptr undef) #3
   ret ptr %0
 }
 
 ; Function Attrs: nounwind
-define hidden ptr @main.Add64(ptr %p, i64 %len, ptr %context) unnamed_addr #1 {
+define hidden ptr @main.Add64(ptr %p, i64 %len, ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
   %0 = trunc i64 %len to i32
   %1 = getelementptr i8, ptr %p, i32 %0
-  call void @runtime.trackPointer(ptr %1, ptr nonnull %stackalloc, ptr undef) #2
+  call void @runtime.trackPointer(ptr %1, ptr nonnull %stackalloc, ptr undef) #3
   ret ptr %1
 }
 
 ; Function Attrs: nounwind
-define hidden ptr @main.SliceToArray(ptr %s.data, i32 %s.len, i32 %s.cap, ptr %context) unnamed_addr #1 {
+define hidden ptr @main.SliceToArray(ptr %s.data, i32 %s.len, i32 %s.cap, ptr %context) unnamed_addr #2 {
 entry:
   %0 = icmp ult i32 %s.len, 4
   br i1 %0, label %slicetoarray.throw, label %slicetoarray.next
@@ -205,18 +206,18 @@ slicetoarray.next:                                ; preds = %entry
   ret ptr %s.data
 
 slicetoarray.throw:                               ; preds = %entry
-  call void @runtime.sliceToArrayPointerPanic(ptr undef) #2
+  call void @runtime.sliceToArrayPointerPanic(ptr undef) #3
   unreachable
 }
 
-declare void @runtime.sliceToArrayPointerPanic(ptr) #0
+declare void @runtime.sliceToArrayPointerPanic(ptr) #1
 
 ; Function Attrs: nounwind
-define hidden ptr @main.SliceToArrayConst(ptr %context) unnamed_addr #1 {
+define hidden ptr @main.SliceToArrayConst(ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
-  %makeslice = call ptr @runtime.alloc(i32 24, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #2
-  call void @runtime.trackPointer(ptr nonnull %makeslice, ptr nonnull %stackalloc, ptr undef) #2
+  %makeslice = call dereferenceable(24) ptr @runtime.alloc(i32 24, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
+  call void @runtime.trackPointer(ptr nonnull %makeslice, ptr nonnull %stackalloc, ptr undef) #3
   br i1 false, label %slicetoarray.throw, label %slicetoarray.next
 
 slicetoarray.next:                                ; preds = %entry
@@ -227,7 +228,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 #1 {
+define hidden { ptr, i32, i32 } @main.SliceInt(ptr dereferenceable_or_null(4) %ptr, i32 %len, ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
   %0 = icmp ugt i32 %len, 1073741823
@@ -241,18 +242,18 @@ unsafe.Slice.next:                                ; preds = %entry
   %5 = insertvalue { ptr, i32, i32 } undef, ptr %ptr, 0
   %6 = insertvalue { ptr, i32, i32 } %5, i32 %len, 1
   %7 = insertvalue { ptr, i32, i32 } %6, i32 %len, 2
-  call void @runtime.trackPointer(ptr %ptr, ptr nonnull %stackalloc, ptr undef) #2
+  call void @runtime.trackPointer(ptr %ptr, ptr nonnull %stackalloc, ptr undef) #3
   ret { ptr, i32, i32 } %7
 
 unsafe.Slice.throw:                               ; preds = %entry
-  call void @runtime.unsafeSlicePanic(ptr undef) #2
+  call void @runtime.unsafeSlicePanic(ptr undef) #3
   unreachable
 }
 
-declare void @runtime.unsafeSlicePanic(ptr) #0
+declare void @runtime.unsafeSlicePanic(ptr) #1
 
 ; Function Attrs: nounwind
-define hidden { ptr, i32, i32 } @main.SliceUint16(ptr dereferenceable_or_null(1) %ptr, i16 %len, ptr %context) unnamed_addr #1 {
+define hidden { ptr, i32, i32 } @main.SliceUint16(ptr dereferenceable_or_null(1) %ptr, i16 %len, ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
   %0 = icmp eq ptr %ptr, null
@@ -265,16 +266,16 @@ unsafe.Slice.next:                                ; preds = %entry
   %4 = insertvalue { ptr, i32, i32 } undef, ptr %ptr, 0
   %5 = insertvalue { ptr, i32, i32 } %4, i32 %3, 1
   %6 = insertvalue { ptr, i32, i32 } %5, i32 %3, 2
-  call void @runtime.trackPointer(ptr %ptr, ptr nonnull %stackalloc, ptr undef) #2
+  call void @runtime.trackPointer(ptr %ptr, ptr nonnull %stackalloc, ptr undef) #3
   ret { ptr, i32, i32 } %6
 
 unsafe.Slice.throw:                               ; preds = %entry
-  call void @runtime.unsafeSlicePanic(ptr undef) #2
+  call void @runtime.unsafeSlicePanic(ptr undef) #3
   unreachable
 }
 
 ; Function Attrs: nounwind
-define hidden { ptr, i32, i32 } @main.SliceUint64(ptr dereferenceable_or_null(4) %ptr, i64 %len, ptr %context) unnamed_addr #1 {
+define hidden { ptr, i32, i32 } @main.SliceUint64(ptr dereferenceable_or_null(4) %ptr, i64 %len, ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
   %0 = icmp ugt i64 %len, 1073741823
@@ -289,16 +290,16 @@ unsafe.Slice.next:                                ; preds = %entry
   %6 = insertvalue { ptr, i32, i32 } undef, ptr %ptr, 0
   %7 = insertvalue { ptr, i32, i32 } %6, i32 %5, 1
   %8 = insertvalue { ptr, i32, i32 } %7, i32 %5, 2
-  call void @runtime.trackPointer(ptr %ptr, ptr nonnull %stackalloc, ptr undef) #2
+  call void @runtime.trackPointer(ptr %ptr, ptr nonnull %stackalloc, ptr undef) #3
   ret { ptr, i32, i32 } %8
 
 unsafe.Slice.throw:                               ; preds = %entry
-  call void @runtime.unsafeSlicePanic(ptr undef) #2
+  call void @runtime.unsafeSlicePanic(ptr undef) #3
   unreachable
 }
 
 ; Function Attrs: nounwind
-define hidden { ptr, i32, i32 } @main.SliceInt64(ptr dereferenceable_or_null(4) %ptr, i64 %len, ptr %context) unnamed_addr #1 {
+define hidden { ptr, i32, i32 } @main.SliceInt64(ptr dereferenceable_or_null(4) %ptr, i64 %len, ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
   %0 = icmp ugt i64 %len, 1073741823
@@ -313,14 +314,15 @@ unsafe.Slice.next:                                ; preds = %entry
   %6 = insertvalue { ptr, i32, i32 } undef, ptr %ptr, 0
   %7 = insertvalue { ptr, i32, i32 } %6, i32 %5, 1
   %8 = insertvalue { ptr, i32, i32 } %7, i32 %5, 2
-  call void @runtime.trackPointer(ptr %ptr, ptr nonnull %stackalloc, ptr undef) #2
+  call void @runtime.trackPointer(ptr %ptr, ptr nonnull %stackalloc, ptr undef) #3
   ret { ptr, i32, i32 } %8
 
 unsafe.Slice.throw:                               ; preds = %entry
-  call void @runtime.unsafeSlicePanic(ptr undef) #2
+  call void @runtime.unsafeSlicePanic(ptr undef) #3
   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 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #1 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #2 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #3 = { nounwind }

compiler/testdata/string.ll

@@ -7,36 +7,37 @@ 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) #0
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #1
 
 ; Function Attrs: nounwind
-define hidden void @main.init(ptr %context) unnamed_addr #1 {
+define hidden void @main.init(ptr %context) unnamed_addr #2 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden %runtime._string @main.someString(ptr %context) unnamed_addr #1 {
+define hidden %runtime._string @main.someString(ptr %context) unnamed_addr #2 {
 entry:
   ret %runtime._string { ptr @"main$string", i32 3 }
 }
 
 ; Function Attrs: nounwind
-define hidden %runtime._string @main.zeroLengthString(ptr %context) unnamed_addr #1 {
+define hidden %runtime._string @main.zeroLengthString(ptr %context) unnamed_addr #2 {
 entry:
   ret %runtime._string zeroinitializer
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.stringLen(ptr %s.data, i32 %s.len, ptr %context) unnamed_addr #1 {
+define hidden i32 @main.stringLen(ptr %s.data, i32 %s.len, ptr %context) unnamed_addr #2 {
 entry:
   ret i32 %s.len
 }
 
 ; Function Attrs: nounwind
-define hidden i8 @main.stringIndex(ptr %s.data, i32 %s.len, i32 %index, ptr %context) unnamed_addr #1 {
+define hidden i8 @main.stringIndex(ptr %s.data, i32 %s.len, i32 %index, ptr %context) unnamed_addr #2 {
 entry:
   %.not = icmp ult i32 %index, %s.len
   br i1 %.not, label %lookup.next, label %lookup.throw
@@ -47,40 +48,40 @@ lookup.next:                                      ; preds = %entry
   ret i8 %1
 
 lookup.throw:                                     ; preds = %entry
-  call void @runtime.lookupPanic(ptr undef) #2
+  call void @runtime.lookupPanic(ptr undef) #3
   unreachable
 }
 
-declare void @runtime.lookupPanic(ptr) #0
+declare void @runtime.lookupPanic(ptr) #1
 
 ; Function Attrs: nounwind
-define hidden i1 @main.stringCompareEqual(ptr %s1.data, i32 %s1.len, ptr %s2.data, i32 %s2.len, ptr %context) unnamed_addr #1 {
+define hidden i1 @main.stringCompareEqual(ptr %s1.data, i32 %s1.len, ptr %s2.data, i32 %s2.len, ptr %context) unnamed_addr #2 {
 entry:
-  %0 = call i1 @runtime.stringEqual(ptr %s1.data, i32 %s1.len, ptr %s2.data, i32 %s2.len, ptr undef) #2
+  %0 = call i1 @runtime.stringEqual(ptr %s1.data, i32 %s1.len, ptr %s2.data, i32 %s2.len, ptr undef) #3
   ret i1 %0
 }
 
-declare i1 @runtime.stringEqual(ptr, i32, ptr, i32, ptr) #0
+declare i1 @runtime.stringEqual(ptr, i32, ptr, i32, ptr) #1
 
 ; Function Attrs: nounwind
-define hidden i1 @main.stringCompareUnequal(ptr %s1.data, i32 %s1.len, ptr %s2.data, i32 %s2.len, ptr %context) unnamed_addr #1 {
+define hidden i1 @main.stringCompareUnequal(ptr %s1.data, i32 %s1.len, ptr %s2.data, i32 %s2.len, ptr %context) unnamed_addr #2 {
 entry:
-  %0 = call i1 @runtime.stringEqual(ptr %s1.data, i32 %s1.len, ptr %s2.data, i32 %s2.len, ptr undef) #2
+  %0 = call i1 @runtime.stringEqual(ptr %s1.data, i32 %s1.len, ptr %s2.data, i32 %s2.len, ptr undef) #3
   %1 = xor i1 %0, true
   ret i1 %1
 }
 
 ; Function Attrs: nounwind
-define hidden i1 @main.stringCompareLarger(ptr %s1.data, i32 %s1.len, ptr %s2.data, i32 %s2.len, ptr %context) unnamed_addr #1 {
+define hidden i1 @main.stringCompareLarger(ptr %s1.data, i32 %s1.len, ptr %s2.data, i32 %s2.len, ptr %context) unnamed_addr #2 {
 entry:
-  %0 = call i1 @runtime.stringLess(ptr %s2.data, i32 %s2.len, ptr %s1.data, i32 %s1.len, ptr undef) #2
+  %0 = call i1 @runtime.stringLess(ptr %s2.data, i32 %s2.len, ptr %s1.data, i32 %s1.len, ptr undef) #3
   ret i1 %0
 }
 
-declare i1 @runtime.stringLess(ptr, i32, ptr, i32, ptr) #0
+declare i1 @runtime.stringLess(ptr, i32, ptr, i32, ptr) #1
 
 ; Function Attrs: nounwind
-define hidden i8 @main.stringLookup(ptr %s.data, i32 %s.len, i8 %x, ptr %context) unnamed_addr #1 {
+define hidden i8 @main.stringLookup(ptr %s.data, i32 %s.len, i8 %x, ptr %context) unnamed_addr #2 {
 entry:
   %0 = zext i8 %x to i32
   %.not = icmp ult i32 %0, %s.len
@@ -92,10 +93,11 @@ lookup.next:                                      ; preds = %entry
   ret i8 %2
 
 lookup.throw:                                     ; preds = %entry
-  call void @runtime.lookupPanic(ptr undef) #2
+  call void @runtime.lookupPanic(ptr undef) #3
   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 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #1 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #2 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #3 = { nounwind }

compiler/testdata/zeromap.go

@@ -0,0 +1,37 @@
+package main
+
+type hasPadding struct {
+	b1 bool
+	i  int
+	b2 bool
+}
+
+type nestedPadding struct {
+	b bool
+	hasPadding
+	i int
+}
+
+//go:noinline
+func testZeroGet(m map[hasPadding]int, s hasPadding) int {
+	return m[s]
+}
+
+//go:noinline
+func testZeroSet(m map[hasPadding]int, s hasPadding) {
+	m[s] = 5
+}
+
+//go:noinline
+func testZeroArrayGet(m map[[2]hasPadding]int, s [2]hasPadding) int {
+	return m[s]
+}
+
+//go:noinline
+func testZeroArraySet(m map[[2]hasPadding]int, s [2]hasPadding) {
+	m[s] = 5
+}
+
+func main() {
+
+}

compiler/testdata/zeromap.ll

@@ -0,0 +1,172 @@
+; ModuleID = 'zeromap.go'
+source_filename = "zeromap.go"
+target datalayout = "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-n32:64-S128-ni:1:10:20"
+target triple = "wasm32-unknown-wasi"
+
+%main.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
+
+; Function Attrs: nounwind
+define hidden void @main.init(ptr %context) unnamed_addr #2 {
+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 {
+entry:
+  %hashmap.key = alloca %main.hasPadding, align 8
+  %hashmap.value = alloca i32, align 4
+  %s = alloca %main.hasPadding, align 8
+  %0 = insertvalue %main.hasPadding zeroinitializer, i1 %s.b1, 0
+  %1 = insertvalue %main.hasPadding %0, i32 %s.i, 1
+  %2 = insertvalue %main.hasPadding %1, i1 %s.b2, 2
+  %stackalloc = alloca i8, align 1
+  store %main.hasPadding zeroinitializer, ptr %s, align 8
+  call void @runtime.trackPointer(ptr nonnull %s, ptr nonnull %stackalloc, ptr undef) #5
+  store %main.hasPadding %2, ptr %s, align 8
+  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 8
+  %3 = getelementptr inbounds i8, ptr %hashmap.key, i32 1
+  call void @runtime.memzero(ptr nonnull %3, i32 3, ptr undef) #5
+  %4 = getelementptr inbounds 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
+  call void @llvm.lifetime.end.p0(i64 12, ptr nonnull %hashmap.key)
+  %6 = load i32, ptr %hashmap.value, align 4
+  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %hashmap.value)
+  ret i32 %6
+}
+
+; Function Attrs: argmemonly nocallback nofree nosync nounwind willreturn
+declare void @llvm.lifetime.start.p0(i64 immarg, ptr nocapture) #4
+
+declare void @runtime.memzero(ptr, i32, ptr) #1
+
+declare i1 @runtime.hashmapBinaryGet(ptr dereferenceable_or_null(40), ptr, ptr, i32, ptr) #1
+
+; Function Attrs: argmemonly nocallback nofree nosync nounwind willreturn
+declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #4
+
+; 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 {
+entry:
+  %hashmap.key = alloca %main.hasPadding, align 8
+  %hashmap.value = alloca i32, align 4
+  %s = alloca %main.hasPadding, align 8
+  %0 = insertvalue %main.hasPadding zeroinitializer, i1 %s.b1, 0
+  %1 = insertvalue %main.hasPadding %0, i32 %s.i, 1
+  %2 = insertvalue %main.hasPadding %1, i1 %s.b2, 2
+  %stackalloc = alloca i8, align 1
+  store %main.hasPadding zeroinitializer, ptr %s, align 8
+  call void @runtime.trackPointer(ptr nonnull %s, ptr nonnull %stackalloc, ptr undef) #5
+  store %main.hasPadding %2, ptr %s, align 8
+  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %hashmap.value)
+  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 8
+  %3 = getelementptr inbounds i8, ptr %hashmap.key, i32 1
+  call void @runtime.memzero(ptr nonnull %3, i32 3, ptr undef) #5
+  %4 = getelementptr inbounds 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 @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
+
+; 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 {
+entry:
+  %hashmap.key = alloca [2 x %main.hasPadding], align 8
+  %hashmap.value = alloca i32, align 4
+  %s1 = alloca [2 x %main.hasPadding], align 8
+  %stackalloc = alloca i8, align 1
+  store %main.hasPadding zeroinitializer, ptr %s1, align 8
+  %s1.repack2 = getelementptr inbounds [2 x %main.hasPadding], ptr %s1, i32 0, i32 1
+  store %main.hasPadding zeroinitializer, ptr %s1.repack2, align 4
+  call void @runtime.trackPointer(ptr nonnull %s1, ptr nonnull %stackalloc, ptr undef) #5
+  %s.elt = extractvalue [2 x %main.hasPadding] %s, 0
+  store %main.hasPadding %s.elt, ptr %s1, align 8
+  %s1.repack3 = getelementptr inbounds [2 x %main.hasPadding], ptr %s1, i32 0, i32 1
+  %s.elt4 = extractvalue [2 x %main.hasPadding] %s, 1
+  store %main.hasPadding %s.elt4, ptr %s1.repack3, align 4
+  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %hashmap.value)
+  call void @llvm.lifetime.start.p0(i64 24, ptr nonnull %hashmap.key)
+  %s.elt7 = extractvalue [2 x %main.hasPadding] %s, 0
+  store %main.hasPadding %s.elt7, ptr %hashmap.key, align 8
+  %hashmap.key.repack8 = getelementptr inbounds [2 x %main.hasPadding], ptr %hashmap.key, i32 0, i32 1
+  %s.elt9 = extractvalue [2 x %main.hasPadding] %s, 1
+  store %main.hasPadding %s.elt9, ptr %hashmap.key.repack8, align 4
+  %0 = getelementptr inbounds i8, ptr %hashmap.key, i32 1
+  call void @runtime.memzero(ptr nonnull %0, i32 3, ptr undef) #5
+  %1 = getelementptr inbounds i8, ptr %hashmap.key, i32 9
+  call void @runtime.memzero(ptr nonnull %1, i32 3, ptr undef) #5
+  %2 = getelementptr inbounds i8, ptr %hashmap.key, i32 13
+  call void @runtime.memzero(ptr nonnull %2, i32 3, ptr undef) #5
+  %3 = getelementptr inbounds 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
+  call void @llvm.lifetime.end.p0(i64 24, ptr nonnull %hashmap.key)
+  %5 = load i32, ptr %hashmap.value, align 4
+  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %hashmap.value)
+  ret i32 %5
+}
+
+; 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 {
+entry:
+  %hashmap.key = alloca [2 x %main.hasPadding], align 8
+  %hashmap.value = alloca i32, align 4
+  %s1 = alloca [2 x %main.hasPadding], align 8
+  %stackalloc = alloca i8, align 1
+  store %main.hasPadding zeroinitializer, ptr %s1, align 8
+  %s1.repack2 = getelementptr inbounds [2 x %main.hasPadding], ptr %s1, i32 0, i32 1
+  store %main.hasPadding zeroinitializer, ptr %s1.repack2, align 4
+  call void @runtime.trackPointer(ptr nonnull %s1, ptr nonnull %stackalloc, ptr undef) #5
+  %s.elt = extractvalue [2 x %main.hasPadding] %s, 0
+  store %main.hasPadding %s.elt, ptr %s1, align 8
+  %s1.repack3 = getelementptr inbounds [2 x %main.hasPadding], ptr %s1, i32 0, i32 1
+  %s.elt4 = extractvalue [2 x %main.hasPadding] %s, 1
+  store %main.hasPadding %s.elt4, ptr %s1.repack3, align 4
+  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %hashmap.value)
+  store i32 5, ptr %hashmap.value, align 4
+  call void @llvm.lifetime.start.p0(i64 24, ptr nonnull %hashmap.key)
+  %s.elt7 = extractvalue [2 x %main.hasPadding] %s, 0
+  store %main.hasPadding %s.elt7, ptr %hashmap.key, align 8
+  %hashmap.key.repack8 = getelementptr inbounds [2 x %main.hasPadding], ptr %hashmap.key, i32 0, i32 1
+  %s.elt9 = extractvalue [2 x %main.hasPadding] %s, 1
+  store %main.hasPadding %s.elt9, ptr %hashmap.key.repack8, align 4
+  %0 = getelementptr inbounds i8, ptr %hashmap.key, i32 1
+  call void @runtime.memzero(ptr nonnull %0, i32 3, ptr undef) #5
+  %1 = getelementptr inbounds i8, ptr %hashmap.key, i32 9
+  call void @runtime.memzero(ptr nonnull %1, i32 3, ptr undef) #5
+  %2 = getelementptr inbounds i8, ptr %hashmap.key, i32 13
+  call void @runtime.memzero(ptr nonnull %2, i32 3, ptr undef) #5
+  %3 = getelementptr inbounds 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 @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 {
+entry:
+  ret void
+}
+
+attributes #0 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #1 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #2 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #3 = { noinline nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #4 = { argmemonly nocallback nofree nosync nounwind willreturn }
+attributes #5 = { nounwind }

compiler/volatile.go

@@ -9,7 +9,7 @@ import "go/types"
 // runtime/volatile.LoadT().
 func (b *builder) createVolatileLoad() {
 	b.createFunctionStart(true)
-	addr := b.getValue(b.fn.Params[0])
+	addr := b.getValue(b.fn.Params[0], getPos(b.fn))
 	b.createNilCheck(b.fn.Params[0], addr, "deref")
 	valType := b.getLLVMType(b.fn.Params[0].Type().(*types.Pointer).Elem())
 	val := b.CreateLoad(valType, addr, "")
@@ -21,8 +21,8 @@ func (b *builder) createVolatileLoad() {
 // runtime/volatile.StoreT().
 func (b *builder) createVolatileStore() {
 	b.createFunctionStart(true)
-	addr := b.getValue(b.fn.Params[0])
-	val := b.getValue(b.fn.Params[1])
+	addr := b.getValue(b.fn.Params[0], getPos(b.fn))
+	val := b.getValue(b.fn.Params[1], getPos(b.fn))
 	b.createNilCheck(b.fn.Params[0], addr, "deref")
 	store := b.CreateStore(val, addr)
 	store.SetVolatile(true)

corpus_test.go

@@ -115,8 +115,9 @@ func TestCorpus(t *testing.T) {
 				var tags buildutil.TagsFlag
 				tags.Set(repo.Tags)
 				opts.Tags = []string(tags)
+				opts.TestConfig.Verbose = testing.Verbose()
 
-				passed, err := Test(path, out, out, &opts, false, testing.Verbose(), false, "", "", "", false, "")
+				passed, err := Test(path, out, out, &opts, "")
 				if err != nil {
 					t.Errorf("test error: %v", err)
 				}

goenv/version.go

@@ -12,7 +12,7 @@ import (
 
 // Version of TinyGo.
 // Update this value before release of new version of software.
-const Version = "0.27.0"
+const Version = "0.28.0-dev"
 
 var (
 	// This variable is set at build time using -ldflags parameters.

interp/README.md

@@ -70,7 +70,7 @@ object. Every memory object is given an index, and pointers use that index to
 look up the current active object for the pointer to load from or to copy
 when storing to it.
 
-Rolling back a function should roll back everyting, including the few
+Rolling back a function should roll back everything, including the few
 instructions emitted at runtime. This is done by treating instructions much
 like memory objects and removing the created instructions when necessary.
 
@@ -88,7 +88,7 @@ LLVM than initialization code. Also, there are a few other benefits:
     they can be propagated and provide some opportunities for other
     optimizations (like dead code elimination when branching on the contents of
     a global).
-  * Constants are much more efficent on microcontrollers, as they can be
+  * Constants are much more efficient on microcontrollers, as they can be
     allocated in flash instead of RAM.
 
 The Go SSA package does not create constant initializers for globals.

interp/compiler.go

@@ -254,7 +254,7 @@ func (r *runner) compileFunction(llvmFn llvm.Value) *function {
 					}
 				}
 			case llvm.BitCast, llvm.IntToPtr, llvm.PtrToInt:
-				// Bitcasts are ususally used to cast a pointer from one type to
+				// Bitcasts are usually used to cast a pointer from one type to
 				// another leaving the pointer itself intact.
 				inst.name = llvmInst.Name()
 				inst.operands = []value{

interp/interpreter.go

@@ -238,7 +238,7 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				// which case this call won't even get to this point but will
 				// already be emitted in initAll.
 				continue
-			case strings.HasPrefix(callFn.name, "runtime.print") || callFn.name == "runtime._panic" || callFn.name == "runtime.hashmapGet" ||
+			case strings.HasPrefix(callFn.name, "runtime.print") || callFn.name == "runtime._panic" || callFn.name == "runtime.hashmapGet" || callFn.name == "runtime.hashmapInterfaceHash" ||
 				callFn.name == "os.runtime_args" || callFn.name == "internal/task.start" || callFn.name == "internal/task.Current":
 				// These functions should be run at runtime. Specifically:
 				//   * Print and panic functions are best emitted directly without
@@ -378,42 +378,6 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				copy(dstBuf.buf[dst.offset():dst.offset()+nBytes], srcBuf.buf[src.offset():])
 				dstObj.buffer = dstBuf
 				mem.put(dst.index(), dstObj)
-			case callFn.name == "(reflect.rawType).elem":
-				if r.debug {
-					fmt.Fprintln(os.Stderr, indent+"call (reflect.rawType).elem:", operands[1:])
-				}
-				// Extract the type code global from the first parameter.
-				typecodeIDPtrToInt, err := operands[1].toLLVMValue(inst.llvmInst.Operand(0).Type(), &mem)
-				if err != nil {
-					return nil, mem, r.errorAt(inst, err)
-				}
-				typecodeID := typecodeIDPtrToInt.Operand(0)
-
-				// Get the type class.
-				// See also: getClassAndValueFromTypeCode in transform/reflect.go.
-				typecodeName := typecodeID.Name()
-				const prefix = "reflect/types.type:"
-				if !strings.HasPrefix(typecodeName, prefix) {
-					panic("unexpected typecode name: " + typecodeName)
-				}
-				id := typecodeName[len(prefix):]
-				class := id[:strings.IndexByte(id, ':')]
-				value := id[len(class)+1:]
-				if class == "named" {
-					// Get the underlying type.
-					class = value[:strings.IndexByte(value, ':')]
-					value = value[len(class)+1:]
-				}
-
-				// Elem() is only valid for certain type classes.
-				switch class {
-				case "chan", "pointer", "slice", "array":
-					elementType := r.builder.CreateExtractValue(typecodeID.Initializer(), 0, "")
-					uintptrType := r.mod.Context().IntType(int(mem.r.pointerSize) * 8)
-					locals[inst.localIndex] = r.getValue(llvm.ConstPtrToInt(elementType, uintptrType))
-				default:
-					return nil, mem, r.errorAt(inst, fmt.Errorf("(reflect.Type).Elem() called on %s type", class))
-				}
 			case callFn.name == "runtime.typeAssert":
 				// This function must be implemented manually as it is normally
 				// implemented by the interface lowering pass.
@@ -424,15 +388,22 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				if err != nil {
 					return nil, mem, r.errorAt(inst, err)
 				}
-				actualTypePtrToInt, err := operands[1].toLLVMValue(inst.llvmInst.Operand(0).Type(), &mem)
+				actualType, err := operands[1].toLLVMValue(inst.llvmInst.Operand(0).Type(), &mem)
 				if err != nil {
 					return nil, mem, r.errorAt(inst, err)
 				}
-				if !actualTypePtrToInt.IsAConstantInt().IsNil() && actualTypePtrToInt.ZExtValue() == 0 {
+				if !actualType.IsAConstantInt().IsNil() && actualType.ZExtValue() == 0 {
 					locals[inst.localIndex] = literalValue{uint8(0)}
 					break
 				}
-				actualType := actualTypePtrToInt.Operand(0)
+				// Strip pointer casts (bitcast, getelementptr).
+				for !actualType.IsAConstantExpr().IsNil() {
+					opcode := actualType.Opcode()
+					if opcode != llvm.GetElementPtr && opcode != llvm.BitCast {
+						break
+					}
+					actualType = actualType.Operand(0)
+				}
 				if strings.TrimPrefix(actualType.Name(), "reflect/types.type:") == strings.TrimPrefix(assertedType.Name(), "reflect/types.typeid:") {
 					locals[inst.localIndex] = literalValue{uint8(1)}
 				} else {
@@ -448,11 +419,12 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				if err != nil {
 					return nil, mem, r.errorAt(inst, err)
 				}
-				methodSetPtr, err := mem.load(typecodePtr.addOffset(r.pointerSize*2), r.pointerSize).asPointer(r)
+				methodSetPtr, err := mem.load(typecodePtr.addOffset(-int64(r.pointerSize)), 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()
@@ -460,9 +432,9 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				// 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 < methodSet.Type().ArrayLength(); i++ {
-					methodInfo := r.builder.CreateExtractValue(methodSet, i, "")
-					name := r.builder.CreateExtractValue(methodInfo, 0, "").Name()
+				for i := 0; i < numMethods; i++ {
+					methodInfo := r.builder.CreateExtractValue(methodSet, 1, "")
+					name := r.builder.CreateExtractValue(methodInfo, i, "").Name()
 					concreteTypeMethods[name] = struct{}{}
 				}
 
@@ -488,15 +460,16 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 					fmt.Fprintln(os.Stderr, indent+"invoke method:", operands[1:])
 				}
 
-				// Load the type code of the interface value.
-				typecodeIDBitCast, err := operands[len(operands)-2].toLLVMValue(inst.llvmInst.Operand(len(operands)-3).Type(), &mem)
+				// Load the type code and method set of the interface value.
+				typecodePtr, err := operands[len(operands)-2].asPointer(r)
 				if err != nil {
 					return nil, mem, r.errorAt(inst, err)
 				}
-				typecodeID := typecodeIDBitCast.Operand(0).Initializer()
-
-				// Load the method set, which is part of the typecodeID object.
-				methodSet := stripPointerCasts(r.builder.CreateExtractValue(typecodeID, 2, "")).Initializer()
+				methodSetPtr, err := mem.load(typecodePtr.addOffset(-int64(r.pointerSize)), r.pointerSize).asPointer(r)
+				if err != nil {
+					return nil, mem, r.errorAt(inst, err)
+				}
+				methodSet := mem.get(methodSetPtr.index()).llvmGlobal.Initializer()
 
 				// We don't need to load the interface method set.
 
@@ -508,13 +481,14 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 
 				// Iterate through all methods, looking for the one method that
 				// should be returned.
-				numMethods := methodSet.Type().ArrayLength()
+				numMethods := int(r.builder.CreateExtractValue(methodSet, 0, "").ZExtValue())
 				var method llvm.Value
 				for i := 0; i < numMethods; i++ {
-					methodSignatureAgg := r.builder.CreateExtractValue(methodSet, i, "")
-					methodSignature := r.builder.CreateExtractValue(methodSignatureAgg, 0, "")
+					methodSignatureAgg := r.builder.CreateExtractValue(methodSet, 1, "")
+					methodSignature := r.builder.CreateExtractValue(methodSignatureAgg, i, "")
 					if methodSignature == signature {
-						method = r.builder.CreateExtractValue(methodSignatureAgg, 1, "").Operand(0)
+						methodAgg := r.builder.CreateExtractValue(methodSet, 2, "")
+						method = r.builder.CreateExtractValue(methodAgg, i, "")
 					}
 				}
 				if method.IsNil() {
@@ -685,7 +659,7 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				}
 				continue
 			}
-			ptr = ptr.addOffset(uint32(offset))
+			ptr = ptr.addOffset(int64(offset))
 			locals[inst.localIndex] = ptr
 			if r.debug {
 				fmt.Fprintln(os.Stderr, indent+"gep:", operands, "->", ptr)
@@ -784,7 +758,7 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				case llvm.Add:
 					// This likely means this is part of a
 					// unsafe.Pointer(uintptr(ptr) + offset) pattern.
-					lhsPtr = lhsPtr.addOffset(uint32(rhs.Uint()))
+					lhsPtr = lhsPtr.addOffset(int64(rhs.Uint()))
 					locals[inst.localIndex] = lhsPtr
 					continue
 				case llvm.Xor:

interp/memory.go

@@ -12,7 +12,7 @@ package interp
 //     done in interp and results in a revert.
 //
 // Right now the memory is assumed to be little endian. This will need an update
-// for big endian arcitectures, if TinyGo ever adds support for one.
+// for big endian architectures, if TinyGo ever adds support for one.
 
 import (
 	"encoding/binary"
@@ -501,7 +501,7 @@ func (v pointerValue) offset() uint32 {
 // addOffset essentially does a GEP operation (pointer arithmetic): it adds the
 // offset to the pointer. It also checks that the offset doesn't overflow the
 // maximum offset size (which is 4GB).
-func (v pointerValue) addOffset(offset uint32) pointerValue {
+func (v pointerValue) addOffset(offset int64) pointerValue {
 	result := pointerValue{v.pointer + uint64(offset)}
 	if checks && v.index() != result.index() {
 		panic("interp: offset out of range")
@@ -815,7 +815,7 @@ func (v rawValue) rawLLVMValue(mem *memoryView) (llvm.Value, error) {
 					// as a ptrtoint, so that they can be used in certain
 					// optimizations.
 					name := elementType.StructName()
-					if name == "runtime.typecodeID" || name == "runtime.funcValueWithSignature" {
+					if name == "runtime.funcValueWithSignature" {
 						uintptrType := ctx.IntType(int(mem.r.pointerSize) * 8)
 						field = llvm.ConstPtrToInt(field, uintptrType)
 					}

interp/testdata/interface.ll

@@ -1,17 +1,16 @@
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64--linux"
 
-%runtime.typecodeID = type { %runtime.typecodeID*, i64, %runtime.interfaceMethodInfo* }
-%runtime.interfaceMethodInfo = type { i8*, i64 }
-
 @main.v1 = global i1 0
 @main.v2 = global i1 0
-@"reflect/types.type:named:main.foo" = private constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:basic:int", i64 0, %runtime.interfaceMethodInfo* null }
+@"reflect/types.type:named:main.foo" = private constant { i8, i8*, i8* } { i8 34, i8* getelementptr inbounds ({ i8, i8* }, { i8, i8* }* @"reflect/types.type:pointer:named:main.foo", i32 0, i32 0), i8* getelementptr inbounds ({ i8, i8* }, { i8, i8* }* @"reflect/types.type:basic:int", i32 0, i32 0) }, align 4
+@"reflect/types.type:pointer:named:main.foo" = external constant { i8, i8* }
 @"reflect/types.typeid:named:main.foo" = external constant i8
-@"reflect/types.type:basic:int" = external constant %runtime.typecodeID
+@"reflect/types.type:basic:int" = private constant { i8, i8* } { i8 2, i8* getelementptr inbounds ({ i8, i8* }, { i8, i8* }* @"reflect/types.type:pointer:basic:int", i32 0, i32 0) }, align 4
+@"reflect/types.type:pointer:basic:int" = external constant { i8, i8* }
 
 
-declare i1 @runtime.typeAssert(i64, i8*, i8*, i8*)
+declare i1 @runtime.typeAssert(i8*, i8*, i8*, i8*)
 
 define void @runtime.initAll() unnamed_addr {
 entry:
@@ -22,9 +21,9 @@ entry:
 define internal void @main.init() unnamed_addr {
 entry:
   ; Test type asserts.
-  %typecode = call i1 @runtime.typeAssert(i64 ptrtoint (%runtime.typecodeID* @"reflect/types.type:named:main.foo" to i64), i8* @"reflect/types.typeid:named:main.foo", i8* undef, i8* null)
+  %typecode = call i1 @runtime.typeAssert(i8* getelementptr inbounds ({ i8, i8*, i8* }, { i8, i8*, i8* }* @"reflect/types.type:named:main.foo", i32 0, i32 0), i8* @"reflect/types.typeid:named:main.foo", i8* undef, i8* null)
   store i1 %typecode, i1* @main.v1
-  %typecode2 = call i1 @runtime.typeAssert(i64 0, i8* @"reflect/types.typeid:named:main.foo", i8* undef, i8* null)
+  %typecode2 = call i1 @runtime.typeAssert(i8* null, i8* @"reflect/types.typeid:named:main.foo", i8* undef, i8* null)
   store i1 %typecode2, i1* @main.v2
   ret void
 }

loader/goroot.go

@@ -231,8 +231,8 @@ func pathsToOverride(goMinor int, needsSyscallPackage bool) map[string]bool {
 		"device/":               false,
 		"examples/":             false,
 		"internal/":             true,
-		"internal/fuzz/":        false,
 		"internal/bytealg/":     false,
+		"internal/fuzz/":        false,
 		"internal/reflectlite/": false,
 		"internal/task/":        false,
 		"machine/":              false,

main.go

@@ -216,39 +216,52 @@ func Build(pkgName, outpath string, options *compileopts.Options) error {
 
 // Test runs the tests in the given package. Returns whether the test passed and
 // possibly an error if the test failed to run.
-func Test(pkgName string, stdout, stderr io.Writer, options *compileopts.Options, testCompileOnly, testVerbose, testShort bool, testRunRegexp string, testBenchRegexp string, testBenchTime string, testBenchMem bool, outpath string) (bool, error) {
+func Test(pkgName string, stdout, stderr io.Writer, options *compileopts.Options, outpath string) (bool, error) {
 	options.TestConfig.CompileTestBinary = true
 	config, err := builder.NewConfig(options)
 	if err != nil {
 		return false, err
 	}
 
+	testConfig := &options.TestConfig
+
 	// Pass test flags to the test binary.
 	var flags []string
-	if testVerbose {
+	if testConfig.Verbose {
 		flags = append(flags, "-test.v")
 	}
-	if testShort {
+	if testConfig.Short {
 		flags = append(flags, "-test.short")
 	}
-	if testRunRegexp != "" {
-		flags = append(flags, "-test.run="+testRunRegexp)
+	if testConfig.RunRegexp != "" {
+		flags = append(flags, "-test.run="+testConfig.RunRegexp)
 	}
-	if testBenchRegexp != "" {
-		flags = append(flags, "-test.bench="+testBenchRegexp)
+	if testConfig.BenchRegexp != "" {
+		flags = append(flags, "-test.bench="+testConfig.BenchRegexp)
 	}
-	if testBenchTime != "" {
-		flags = append(flags, "-test.benchtime="+testBenchTime)
+	if testConfig.BenchTime != "" {
+		flags = append(flags, "-test.benchtime="+testConfig.BenchTime)
 	}
-	if testBenchMem {
+	if testConfig.BenchMem {
 		flags = append(flags, "-test.benchmem")
 	}
+	if testConfig.Count != nil && *testConfig.Count != 1 {
+		flags = append(flags, "-test.count="+strconv.Itoa(*testConfig.Count))
+	}
+
+	logToStdout := testConfig.Verbose || testConfig.BenchRegexp != ""
+
+	var buf bytes.Buffer
+	var output io.Writer = &buf
+	// Send the test output to stdout if -v or -bench
+	if logToStdout {
+		output = os.Stdout
+	}
 
-	buf := bytes.Buffer{}
 	passed := false
 	var duration time.Duration
-	result, err := buildAndRun(pkgName, config, &buf, flags, nil, 0, func(cmd *exec.Cmd, result builder.BuildResult) error {
-		if testCompileOnly || outpath != "" {
+	result, err := buildAndRun(pkgName, config, output, flags, nil, 0, func(cmd *exec.Cmd, result builder.BuildResult) error {
+		if testConfig.CompileOnly || outpath != "" {
 			// Write test binary to the specified file name.
 			if outpath == "" {
 				// No -o path was given, so create one now.
@@ -257,7 +270,7 @@ func Test(pkgName string, stdout, stderr io.Writer, options *compileopts.Options
 			}
 			copyFile(result.Binary, outpath)
 		}
-		if testCompileOnly {
+		if testConfig.CompileOnly {
 			// Do not run the test.
 			passed = true
 			return nil
@@ -305,11 +318,9 @@ func Test(pkgName string, stdout, stderr io.Writer, options *compileopts.Options
 		duration = time.Since(start)
 		passed = err == nil
 
-		// print the test output if
-		// 1) the tests passed and in verbose mode
-		// 2) the tests failed
-		// 3) running benchmarks
-		if (passed && testVerbose) || (!passed) || (testBenchRegexp != "") {
+		// if verbose or benchmarks, then output is already going to stdout
+		// However, if we failed and weren't printing to stdout, print the output we accumulated.
+		if !passed && !logToStdout {
 			buf.WriteTo(stdout)
 		}
 
@@ -322,14 +333,19 @@ func Test(pkgName string, stdout, stderr io.Writer, options *compileopts.Options
 		return err
 	})
 	importPath := strings.TrimSuffix(result.ImportPath, ".test")
+
+	var w io.Writer = stdout
+	if logToStdout {
+		w = os.Stdout
+	}
 	if err, ok := err.(loader.NoTestFilesError); ok {
-		fmt.Fprintf(stdout, "?   \t%s\t[no test files]\n", err.ImportPath)
+		fmt.Fprintf(w, "?   \t%s\t[no test files]\n", err.ImportPath)
 		// Pretend the test passed - it at least didn't fail.
 		return true, nil
 	} else if passed {
-		fmt.Fprintf(stdout, "ok  \t%s\t%.3fs\n", importPath, duration.Seconds())
+		fmt.Fprintf(w, "ok  \t%s\t%.3fs\n", importPath, duration.Seconds())
 	} else {
-		fmt.Fprintf(stdout, "FAIL\t%s\t%.3fs\n", importPath, duration.Seconds())
+		fmt.Fprintf(w, "FAIL\t%s\t%.3fs\n", importPath, duration.Seconds())
 	}
 	return passed, err
 }
@@ -644,7 +660,7 @@ func Debug(debugger, pkgName string, ocdOutput bool, options *compileopts.Option
 	case "qemu-user":
 		port = ":1234"
 		// Run in an emulator.
-		args := append(emulator[1:], "-g", "1234")
+		args := append([]string{"-g", "1234"}, emulator[1:]...)
 		daemon = executeCommand(config.Options, emulator[0], args...)
 		daemon.Stdout = os.Stdout
 		daemon.Stderr = os.Stderr
@@ -776,6 +792,7 @@ func buildAndRun(pkgName string, config *compileopts.Config, stdout io.Writer, c
 		}
 	}
 	var args, env []string
+	var extraCmdEnv []string
 	if needsEnvInVars {
 		runtimeGlobals := make(map[string]string)
 		if len(cmdArgs) != 0 {
@@ -806,6 +823,11 @@ func buildAndRun(pkgName string, config *compileopts.Config, stdout io.Writer, c
 			args = append(args, "--")
 			args = append(args, cmdArgs...)
 		}
+
+		// Set this for nicer backtraces during tests, but don't override the user.
+		if _, ok := os.LookupEnv("WASMTIME_BACKTRACE_DETAILS"); !ok {
+			extraCmdEnv = append(extraCmdEnv, "WASMTIME_BACKTRACE_DETAILS=1")
+		}
 	} else {
 		// Pass environment variables and command line parameters as usual.
 		// This also works on qemu-aarch64 etc.
@@ -857,7 +879,8 @@ func buildAndRun(pkgName string, config *compileopts.Config, stdout io.Writer, c
 	} else {
 		cmd = exec.Command(name, args...)
 	}
-	cmd.Env = env
+	cmd.Env = append(cmd.Env, env...)
+	cmd.Env = append(cmd.Env, extraCmdEnv...)
 
 	// Configure stdout/stderr. The stdout may go to a buffer, not a real
 	// stdout.
@@ -1404,19 +1427,17 @@ func main() {
 	if command == "help" || command == "build" || command == "build-library" || command == "test" {
 		flag.StringVar(&outpath, "o", "", "output filename")
 	}
-	var testCompileOnlyFlag, testVerboseFlag, testShortFlag *bool
-	var testBenchRegexp *string
-	var testBenchTime *string
-	var testRunRegexp *string
-	var testBenchMem *bool
+
+	var testConfig compileopts.TestConfig
 	if command == "help" || command == "test" {
-		testCompileOnlyFlag = flag.Bool("c", false, "compile the test binary but do not run it")
-		testVerboseFlag = flag.Bool("v", false, "verbose: print additional output")
-		testShortFlag = flag.Bool("short", false, "short: run smaller test suite to save time")
-		testRunRegexp = flag.String("run", "", "run: regexp of tests to run")
-		testBenchRegexp = flag.String("bench", "", "run: regexp of benchmarks to run")
-		testBenchTime = flag.String("benchtime", "", "run each benchmark for duration `d`")
-		testBenchMem = flag.Bool("benchmem", false, "show memory stats for benchmarks")
+		flag.BoolVar(&testConfig.CompileOnly, "c", false, "compile the test binary but do not run it")
+		flag.BoolVar(&testConfig.Verbose, "v", false, "verbose: print additional output")
+		flag.BoolVar(&testConfig.Short, "short", false, "short: run smaller test suite to save time")
+		flag.StringVar(&testConfig.RunRegexp, "run", "", "run: regexp of tests to run")
+		testConfig.Count = flag.Int("count", 1, "count: number of times to run tests/benchmarks `count` times")
+		flag.StringVar(&testConfig.BenchRegexp, "bench", "", "run: regexp of benchmarks to run")
+		flag.StringVar(&testConfig.BenchTime, "benchtime", "", "run each benchmark for duration `d`")
+		flag.BoolVar(&testConfig.BenchMem, "benchmem", false, "show memory stats for benchmarks")
 	}
 
 	// Early command processing, before commands are interpreted by the Go flag
@@ -1474,6 +1495,7 @@ func main() {
 		PrintStacks:     *printStacks,
 		PrintAllocs:     printAllocs,
 		Tags:            []string(tags),
+		TestConfig:      testConfig,
 		GlobalValues:    globalVarValues,
 		Programmer:      *programmer,
 		OpenOCDCommands: ocdCommands,
@@ -1508,6 +1530,15 @@ func main() {
 		defer pprof.StopCPUProfile()
 	}
 
+	// Limit the number of threads to one.
+	// This is an attempted workaround for the crashes we're seeing in CI on
+	// Windows. If this change helps, it indicates there is a concurrency issue.
+	// If it doesn't, then there is something else going on. Either way, this
+	// should be removed once the test is done.
+	if runtime.GOOS == "windows" {
+		runtime.GOMAXPROCS(1)
+	}
+
 	switch command {
 	case "build":
 		pkgName := "."
@@ -1650,7 +1681,7 @@ func main() {
 				defer close(buf.done)
 				stdout := (*testStdout)(buf)
 				stderr := (*testStderr)(buf)
-				passed, err := Test(pkgName, stdout, stderr, options, *testCompileOnlyFlag, *testVerboseFlag, *testShortFlag, *testRunRegexp, *testBenchRegexp, *testBenchTime, *testBenchMem, outpath)
+				passed, err := Test(pkgName, stdout, stderr, options, outpath)
 				if err != nil {
 					printCompilerError(func(args ...interface{}) {
 						fmt.Fprintln(stderr, args...)

main_test.go

@@ -180,7 +180,8 @@ func runPlatTests(options compileopts.Options, tests []string, t *testing.T) {
 			// Skip the ones that aren't.
 			switch name {
 			case "reflect.go":
-				// Reflect tests do not work due to type code issues.
+				// Reflect tests do not run correctly, probably because of the
+				// limited amount of memory.
 				continue
 
 			case "gc.go":
@@ -188,20 +189,16 @@ func runPlatTests(options compileopts.Options, tests []string, t *testing.T) {
 				continue
 
 			case "json.go", "stdlib.go", "testing.go":
-				// Breaks interp.
+				// Too big for AVR. Doesn't fit in flash/RAM.
 				continue
 
 			case "math.go":
-				// Stuck somewhere, not sure what's happening.
+				// Needs newer picolibc version (for sqrt).
 				continue
 
 			case "cgo/":
-				// CGo does not work on AVR.
-				continue
-
-			case "timers.go":
-				// Doesn't compile:
-				//   panic: compiler: could not store type code number inside interface type code
+				// CGo function pointers don't work on AVR (needs LLVM 16 and
+				// some compiler changes).
 				continue
 
 			default:
@@ -428,7 +425,7 @@ func TestTest(t *testing.T) {
 				defer out.Close()
 
 				opts := targ.opts
-				passed, err := Test("github.com/tinygo-org/tinygo/tests/testing/pass", out, out, &opts, false, false, false, "", "", "", false, "")
+				passed, err := Test("github.com/tinygo-org/tinygo/tests/testing/pass", out, out, &opts, "")
 				if err != nil {
 					t.Errorf("test error: %v", err)
 				}
@@ -449,7 +446,7 @@ func TestTest(t *testing.T) {
 				defer out.Close()
 
 				opts := targ.opts
-				passed, err := Test("github.com/tinygo-org/tinygo/tests/testing/fail", out, out, &opts, false, false, false, "", "", "", false, "")
+				passed, err := Test("github.com/tinygo-org/tinygo/tests/testing/fail", out, out, &opts, "")
 				if err != nil {
 					t.Errorf("test error: %v", err)
 				}
@@ -476,7 +473,7 @@ func TestTest(t *testing.T) {
 
 				var output bytes.Buffer
 				opts := targ.opts
-				passed, err := Test("github.com/tinygo-org/tinygo/tests/testing/nothing", io.MultiWriter(&output, out), out, &opts, false, false, false, "", "", "", false, "")
+				passed, err := Test("github.com/tinygo-org/tinygo/tests/testing/nothing", io.MultiWriter(&output, out), out, &opts, "")
 				if err != nil {
 					t.Errorf("test error: %v", err)
 				}
@@ -500,7 +497,7 @@ func TestTest(t *testing.T) {
 				defer out.Close()
 
 				opts := targ.opts
-				passed, err := Test("github.com/tinygo-org/tinygo/tests/testing/builderr", out, out, &opts, false, false, false, "", "", "", false, "")
+				passed, err := Test("github.com/tinygo-org/tinygo/tests/testing/builderr", out, out, &opts, "")
 				if err == nil {
 					t.Error("test did not error")
 				}

src/device/arm/arm.go

@@ -29,6 +29,7 @@
 //	POSSIBILITY OF SUCH DAMAGE.
 package arm
 
+import "C"
 import (
 	"errors"
 	"runtime/volatile"
@@ -174,20 +175,15 @@ func SetPriority(irq uint32, priority uint32) {
 
 // DisableInterrupts disables all interrupts, and returns the old interrupt
 // state.
-func DisableInterrupts() uintptr {
-	return AsmFull(`
-		mrs {}, PRIMASK
-		cpsid i
-	`, nil)
-}
+//
+//export DisableInterrupts
+func DisableInterrupts() uintptr
 
 // EnableInterrupts enables all interrupts again. The value passed in must be
 // the mask returned by DisableInterrupts.
-func EnableInterrupts(mask uintptr) {
-	AsmFull("msr PRIMASK, {mask}", map[string]interface{}{
-		"mask": mask,
-	})
-}
+//
+//export EnableInterrupts
+func EnableInterrupts(mask uintptr)
 
 // Set up the system timer to generate periodic tick events.
 // This will cause SysTick_Handler to fire once per tick.

src/device/arm/interrupts.c

@@ -0,0 +1,22 @@
+#include <stdint.h>
+
+void EnableInterrupts(uintptr_t mask) {
+    asm volatile(
+        "msr PRIMASK, %0"
+        :
+        : "r"(mask)
+        : "memory"
+    );
+}
+
+uintptr_t DisableInterrupts() {
+    uintptr_t mask;
+    asm volatile(
+        "mrs %0, PRIMASK\n\t"
+        "cpsid i"
+        : "=r"(mask)
+        :
+        : "memory"
+    );
+	return mask;
+}

src/device/gba/gba.go

@@ -0,0 +1,474 @@
+// Hand written file mostly derived from https://problemkaputt.de/gbatek.htm
+
+//go:build gameboyadvance
+
+package gba
+
+import (
+	"runtime/volatile"
+	"unsafe"
+)
+
+// Interrupt numbers.
+const (
+	IRQ_VBLANK  = 0
+	IRQ_HBLANK  = 1
+	IRQ_VCOUNT  = 2
+	IRQ_TIMER0  = 3
+	IRQ_TIMER1  = 4
+	IRQ_TIMER2  = 5
+	IRQ_TIMER3  = 6
+	IRQ_COM     = 7
+	IRQ_DMA0    = 8
+	IRQ_DMA1    = 9
+	IRQ_DMA2    = 10
+	IRQ_DMA3    = 11
+	IRQ_KEYPAD  = 12
+	IRQ_GAMEPAK = 13
+)
+
+// Peripherals
+var (
+	// Display registers
+	DISP = (*DISP_Type)(unsafe.Add(unsafe.Pointer(REG_BASE), uintptr(0x0000)))
+
+	// Background control registers
+	BGCNT0 = (*BGCNT_Type)(unsafe.Add(unsafe.Pointer(REG_BASE), uintptr(0x0008)))
+	BGCNT1 = (*BGCNT_Type)(unsafe.Add(unsafe.Pointer(REG_BASE), uintptr(0x000A)))
+	BGCNT2 = (*BGCNT_Type)(unsafe.Add(unsafe.Pointer(REG_BASE), uintptr(0x000C)))
+	BGCNT3 = (*BGCNT_Type)(unsafe.Add(unsafe.Pointer(REG_BASE), uintptr(0x000E)))
+
+	BG0 = (*BG_Type)(unsafe.Add(unsafe.Pointer(REG_BASE), uintptr(0x0010)))
+	BG1 = (*BG_Type)(unsafe.Add(unsafe.Pointer(REG_BASE), uintptr(0x0014)))
+	BG2 = (*BG_Type)(unsafe.Add(unsafe.Pointer(REG_BASE), uintptr(0x0018)))
+	BG3 = (*BG_Type)(unsafe.Add(unsafe.Pointer(REG_BASE), uintptr(0x001C)))
+
+	BGA2 = (*BG_AFFINE_Type)(unsafe.Add(unsafe.Pointer(REG_BASE), uintptr(0x0020)))
+	BGA3 = (*BG_AFFINE_Type)(unsafe.Add(unsafe.Pointer(REG_BASE), uintptr(0x0030)))
+
+	WIN = (*WIN_Type)(unsafe.Add(unsafe.Pointer(REG_BASE), uintptr(0x0040)))
+
+	GRAPHICS = (*GRAPHICS_Type)(unsafe.Add(unsafe.Pointer(REG_BASE), uintptr(0x004C)))
+
+	// GBA Sound Channel 1 - Tone & Sweep
+	SOUND1 = (*SOUND_Type)(unsafe.Add(unsafe.Pointer(REG_BASE), uintptr(0x0060)))
+
+	// GBA Sound Channel 2 - Tone
+	SOUND2 = (*SOUND_Type)(unsafe.Add(unsafe.Pointer(REG_BASE), uintptr(0x0068)))
+
+	// TODO: Sound channel 3 and 4
+
+	TM0 = (*TIMER_Type)(unsafe.Add(unsafe.Pointer(REG_BASE), uintptr(0x0100)))
+	TM1 = (*TIMER_Type)(unsafe.Add(unsafe.Pointer(REG_BASE), uintptr(0x0104)))
+	TM2 = (*TIMER_Type)(unsafe.Add(unsafe.Pointer(REG_BASE), uintptr(0x0108)))
+	TM3 = (*TIMER_Type)(unsafe.Add(unsafe.Pointer(REG_BASE), uintptr(0x010C)))
+
+	KEY = (*KEY_Type)(unsafe.Add(unsafe.Pointer(REG_BASE), uintptr(0x0130)))
+
+	INTERRUPT = (*INTERRUPT_Type)(unsafe.Add(unsafe.Pointer(REG_BASE), uintptr(0x0200)))
+)
+
+// Main memory sections
+const (
+	// External work RAM
+	MEM_EWRAM uintptr = 0x02000000
+
+	// Internal work RAM
+	MEM_IWRAM uintptr = 0x03000000
+
+	// I/O registers
+	MEM_IO uintptr = 0x04000000
+
+	// Palette. Note: no 8bit write !!
+	MEM_PAL uintptr = 0x05000000
+
+	// Video RAM. Note: no 8bit write !!
+	MEM_VRAM uintptr = 0x06000000
+
+	// Object Attribute Memory (OAM) Note: no 8bit write !!
+	MEM_OAM uintptr = 0x07000000
+
+	// ROM. No write at all (duh)
+	MEM_ROM uintptr = 0x08000000
+
+	// Static RAM. 8bit write only
+	MEM_SRAM uintptr = 0x0E000000
+)
+
+// Main section sizes
+const (
+	EWRAM_SIZE uintptr = 0x40000
+	IWRAM_SIZE uintptr = 0x08000
+	PAL_SIZE   uintptr = 0x00400
+	VRAM_SIZE  uintptr = 0x18000
+	OAM_SIZE   uintptr = 0x00400
+	SRAM_SIZE  uintptr = 0x10000
+)
+
+// Sub section sizes
+const (
+	// BG palette size
+	PAL_BG_SIZE = 0x00200
+
+	// Object palette size
+	PAL_OBJ_SIZE = 0x00200
+
+	// Charblock size
+	CBB_SIZE = 0x04000
+
+	// Screenblock size
+	SBB_SIZE = 0x00800
+
+	// BG VRAM size
+	VRAM_BG_SIZE = 0x10000
+
+	// Object VRAM size
+	VRAM_OBJ_SIZE = 0x08000
+
+	// Mode 3 buffer size
+	M3_SIZE = 0x12C00
+
+	// Mode 4 buffer size
+	M4_SIZE = 0x09600
+
+	// Mode 5 buffer size
+	M5_SIZE = 0x0A000
+
+	// Bitmap page size
+	VRAM_PAGE_SIZE = 0x0A000
+)
+
+// Sub sections
+var (
+	REG_BASE uintptr = MEM_IO
+
+	// Background palette address
+	MEM_PAL_BG = MEM_PAL
+
+	// Object palette address
+	MEM_PAL_OBJ = MEM_PAL + PAL_BG_SIZE
+
+	// Front page address
+	MEM_VRAM_FRONT = MEM_VRAM
+
+	// Back page address
+	MEM_VRAM_BACK = MEM_VRAM + VRAM_PAGE_SIZE
+
+	// Object VRAM address
+	MEM_VRAM_OBJ = MEM_VRAM + VRAM_BG_SIZE
+)
+
+// Display registers
+type DISP_Type struct {
+	DISPCNT  volatile.Register16
+	_        [2]byte
+	DISPSTAT volatile.Register16
+	VCOUNT   volatile.Register16
+}
+
+// Background control registers
+type BGCNT_Type struct {
+	CNT volatile.Register16
+}
+
+// Regular background scroll registers. (write only!)
+type BG_Type struct {
+	HOFS volatile.Register16
+	VOFS volatile.Register16
+}
+
+// Affine background parameters. (write only!)
+type BG_AFFINE_Type struct {
+	PA volatile.Register16
+	PB volatile.Register16
+	PC volatile.Register16
+	PD volatile.Register16
+	X  volatile.Register32
+	Y  volatile.Register32
+}
+
+type WIN_Type struct {
+	// win0 right, left (0xLLRR)
+	WIN0H volatile.Register16
+
+	// win1 right, left (0xLLRR)
+	WIN1H volatile.Register16
+
+	// win0 bottom, top (0xTTBB)
+	WIN0V volatile.Register16
+
+	// win1 bottom, top (0xTTBB)
+	WIN1V volatile.Register16
+
+	// win0, win1 control
+	IN volatile.Register16
+
+	// winOut, winObj control
+	OUT volatile.Register16
+}
+
+type GRAPHICS_Type struct {
+	// Mosaic control
+	MOSAIC volatile.Register32
+
+	// Alpha control
+	BLDCNT volatile.Register16
+
+	// Fade level
+	BLDALPHA volatile.Register16
+
+	// Blend levels
+	BLDY volatile.Register16
+}
+
+type SOUND_Type struct {
+	// Sweep register
+	CNT_L volatile.Register16
+
+	// Duty/Len/Envelope
+	CNT_H volatile.Register16
+
+	// Frequency/Control
+	CNT_X volatile.Register16
+}
+
+// TODO: DMA
+
+// TIMER
+type TIMER_Type struct {
+	DATA volatile.Register16
+	CNT  volatile.Register16
+}
+
+// TODO: serial
+
+// Keypad registers
+type KEY_Type struct {
+	INPUT volatile.Register16
+	CNT   volatile.Register16
+}
+
+// TODO: Joybus communication
+
+// Interrupt / System registers
+type INTERRUPT_Type struct {
+	IE      volatile.Register16
+	IF      volatile.Register16
+	WAITCNT volatile.Register16
+	IME     volatile.Register16
+	PAUSE   volatile.Register16
+}
+
+// Constants for DISP: display
+const (
+	// BGMODE: background mode.
+	// Position of BGMODE field.
+	DISPCNT_BGMODE_Pos = 0x0
+	// Bit mask of BGMODE field.
+	DISPCNT_BGMODE_Msk = 0x4
+	// BG Mode 0.
+	DISPCNT_BGMODE_0 = 0x0
+	// BG Mode 1.
+	DISPCNT_BGMODE_1 = 0x1
+	// BG Mode 2.
+	DISPCNT_BGMODE_2 = 0x2
+	// BG Mode 3.
+	DISPCNT_BGMODE_3 = 0x3
+	// BG Mode 4.
+	DISPCNT_BGMODE_4 = 0x4
+
+	// FRAMESELECT: frame select (mode 4 and 5 only).
+	DISPCNT_FRAMESELECT_Pos    = 0x4
+	DISPCNT_FRAMESELECT_FRAME0 = 0x0
+	DISPCNT_FRAMESELECT_FRAME1 = 0x1
+
+	// HBLANKINTERVAL: 1=Allow access to OAM during H-Blank
+	DISPCNT_HBLANKINTERVAL_Pos     = 0x5
+	DISPCNT_HBLANKINTERVAL_NOALLOW = 0x0
+	DISPCNT_HBLANKINTERVAL_ALLOW   = 0x1
+
+	// OBJCHARVRAM: (0=Two dimensional, 1=One dimensional)
+	DISPCNT_OBJCHARVRAM_Pos = 0x6
+	DISPCNT_OBJCHARVRAM_2D  = 0x0
+	DISPCNT_OBJCHARVRAM_1D  = 0x1
+
+	// FORCEDBLANK: (1=Allow FAST access to VRAM,Palette,OAM)
+	DISPCNT_FORCEDBLANK_Pos     = 0x7
+	DISPCNT_FORCEDBLANK_NOALLOW = 0x0
+	DISPCNT_FORCEDBLANK_ALLOW   = 0x1
+
+	// Screen Display BG0
+	DISPCNT_SCREENDISPLAY_BG0_Pos     = 0x8
+	DISPCNT_SCREENDISPLAY_BG0_ENABLE  = 0x1
+	DISPCNT_SCREENDISPLAY_BG0_DISABLE = 0x0
+
+	// Screen Display BG1
+	DISPCNT_SCREENDISPLAY_BG1_Pos     = 0x9
+	DISPCNT_SCREENDISPLAY_BG1_ENABLE  = 0x1
+	DISPCNT_SCREENDISPLAY_BG1_DISABLE = 0x0
+
+	// Screen Display BG2
+	DISPCNT_SCREENDISPLAY_BG2_Pos     = 0xA
+	DISPCNT_SCREENDISPLAY_BG2_ENABLE  = 0x1
+	DISPCNT_SCREENDISPLAY_BG2_DISABLE = 0x0
+
+	// Screen Display BG3
+	DISPCNT_SCREENDISPLAY_BG3_Pos     = 0xB
+	DISPCNT_SCREENDISPLAY_BG3_ENABLE  = 0x1
+	DISPCNT_SCREENDISPLAY_BG3_DISABLE = 0x0
+
+	// Screen Display OBJ
+	DISPCNT_SCREENDISPLAY_OBJ_Pos     = 0xC
+	DISPCNT_SCREENDISPLAY_OBJ_ENABLE  = 0x1
+	DISPCNT_SCREENDISPLAY_OBJ_DISABLE = 0x0
+
+	// Window 0 Display Flag (0=Off, 1=On)
+	DISPCNT_WINDOW0_DISPLAY_Pos     = 0xD
+	DISPCNT_WINDOW0_DISPLAY_ENABLE  = 0x1
+	DISPCNT_WINDOW0_DISPLAY_DISABLE = 0x0
+
+	// Window 1 Display Flag (0=Off, 1=On)
+	DISPCNT_WINDOW1_DISPLAY_Pos     = 0xE
+	DISPCNT_WINDOW1_DISPLAY_ENABLE  = 0x1
+	DISPCNT_WINDOW1_DISPLAY_DISABLE = 0x0
+
+	// OBJ Window Display Flag
+	DISPCNT_WINDOWOBJ_DISPLAY_Pos     = 0xF
+	DISPCNT_WINDOWOBJ_DISPLAY_ENABLE  = 0x1
+	DISPCNT_WINDOWOBJ_DISPLAY_DISABLE = 0x0
+
+	// DISPSTAT: display status.
+	// V-blank
+	DISPSTAT_VBLANK_Pos     = 0x0
+	DISPSTAT_VBLANK_ENABLE  = 0x1
+	DISPSTAT_VBLANK_DISABLE = 0x0
+
+	// H-blank
+	DISPSTAT_HBLANK_Pos     = 0x1
+	DISPSTAT_HBLANK_ENABLE  = 0x1
+	DISPSTAT_HBLANK_DISABLE = 0x0
+
+	// V-counter match
+	DISPSTAT_VCOUNTER_Pos     = 0x2
+	DISPSTAT_VCOUNTER_MATCH   = 0x1
+	DISPSTAT_VCOUNTER_NOMATCH = 0x0
+
+	// V-blank IRQ
+	DISPSTAT_VBLANK_IRQ_Pos     = 0x3
+	DISPSTAT_VBLANK_IRQ_ENABLE  = 0x1
+	DISPSTAT_VBLANK_IRQ_DISABLE = 0x0
+
+	// H-blank IRQ
+	DISPSTAT_HBLANK_IRQ_Pos     = 0x4
+	DISPSTAT_HBLANK_IRQ_ENABLE  = 0x1
+	DISPSTAT_HBLANK_IRQ_DISABLE = 0x0
+
+	// V-counter IRQ
+	DISPSTAT_VCOUNTER_IRQ_Pos     = 0x5
+	DISPSTAT_VCOUNTER_IRQ_ENABLE  = 0x1
+	DISPSTAT_VCOUNTER_IRQ_DISABLE = 0x0
+
+	// V-count setting
+	DISPSTAT_VCOUNT_SETTING_Pos = 0x8
+)
+
+// Constants for TIMER
+const (
+	// PRESCALER: Prescaler Selection (0=F/1, 1=F/64, 2=F/256, 3=F/1024)
+	// Position of PRESCALER field.
+	TIMERCNT_PRESCALER_Pos = 0x0
+	// Bit mask of PRESCALER field.
+	TIMERCNT_PRESCALER_Msk = 0x2
+	// 0=F/1
+	TIMERCNT_PRESCALER_1 = 0x0
+	// 1=F/64
+	TIMERCNT_PRESCALER_64 = 0x1
+	// 2=F/256
+	TIMERCNT_PRESCALER_256 = 0x2
+	// F/1024
+	TIMERCNT_PRESCALER_1024 = 0x3
+
+	// COUNTUP: Count-up Timing   (0=Normal, 1=See below)  ;Not used in TM0CNT_H
+	// Position of COUNTUP_TIMING field.
+	TIMERCNT_COUNTUP_TIMING_Pos     = 0x2
+	TIMERCNT_COUNTUP_TIMING_NORMAL  = 0x0
+	TIMERCNT_COUNTUP_TIMING_ENABLED = 0x1
+
+	TIMERCNT_TIMER_IRQ_ENABLED_Pos = 0x06
+	TIMERCNT_TIMER_IRQ_ENABLED     = 0x01
+	TIMERCNT_TIMER_IRQ_DISABLED    = 0x00
+
+	TIMERCNT_TIMER_STARTSTOP_Pos = 0x07
+	TIMERCNT_TIMER_START         = 0x1
+	TIMERCNT_TIMER_STOP          = 0x0
+)
+
+// Constants for KEY
+const (
+	// KEYINPUT
+	KEYINPUT_PRESSED           = 0x0
+	KEYINPUT_RELEASED          = 0x1
+	KEYINPUT_BUTTON_A_Pos      = 0x0
+	KEYINPUT_BUTTON_B_Pos      = 0x1
+	KEYINPUT_BUTTON_SELECT_Pos = 0x2
+	KEYINPUT_BUTTON_START_Pos  = 0x3
+	KEYINPUT_BUTTON_RIGHT_Pos  = 0x4
+	KEYINPUT_BUTTON_LEFT_Pos   = 0x5
+	KEYINPUT_BUTTON_UP_Pos     = 0x6
+	KEYINPUT_BUTTON_DOWN_Pos   = 0x7
+	KEYINPUT_BUTTON_R_Pos      = 0x8
+	KEYINPUT_BUTTON_L_Pos      = 0x9
+
+	// KEYCNT
+	KEYCNT_IGNORE            = 0x0
+	KEYCNT_SELECT            = 0x1
+	KEYCNT_BUTTON_A_Pos      = 0x0
+	KEYCNT_BUTTON_B_Pos      = 0x1
+	KEYCNT_BUTTON_SELECT_Pos = 0x2
+	KEYCNT_BUTTON_START_Pos  = 0x3
+	KEYCNT_BUTTON_RIGHT_Pos  = 0x4
+	KEYCNT_BUTTON_LEFT_Pos   = 0x5
+	KEYCNT_BUTTON_UP_Pos     = 0x6
+	KEYCNT_BUTTON_DOWN_Pos   = 0x7
+	KEYCNT_BUTTON_R_Pos      = 0x8
+	KEYCNT_BUTTON_L_Pos      = 0x9
+)
+
+// Constants for INTERRUPT
+const (
+	// IE
+	INTERRUPT_IE_ENABLED             = 0x1
+	INTERRUPT_IE_DISABLED            = 0x0
+	INTERRUPT_IE_VBLANK_Pos          = 0x0
+	INTERRUPT_IE_HBLANK_Pos          = 0x1
+	INTERRUPT_IE_VCOUNTER_MATCH_Pos  = 0x2
+	INTERRUPT_IE_TIMER0_OVERFLOW_Pos = 0x3
+	INTERRUPT_IE_TIMER1_OVERFLOW_Pos = 0x4
+	INTERRUPT_IE_TIMER2_OVERFLOW_Pos = 0x5
+	INTERRUPT_IE_TIMER3_OVERFLOW_Pos = 0x6
+	INTERRUPT_IE_SERIAL_Pos          = 0x7
+	INTERRUPT_IE_DMA0_Pos            = 0x8
+	INTERRUPT_IE_DMA1_Pos            = 0x9
+	INTERRUPT_IE_DMA2_Pos            = 0xA
+	INTERRUPT_IE_DMA3_Pos            = 0xB
+	INTERRUPT_IE_KEYPAD_Pos          = 0xC
+	INTERRUPT_IE_GAMPAK_Pos          = 0xD
+
+	// IF
+	INTERRUPT_IF_ENABLED             = 0x1
+	INTERRUPT_IF_DISABLED            = 0x0
+	INTERRUPT_IF_VBLANK_Pos          = 0x0
+	INTERRUPT_IF_HBLANK_Pos          = 0x1
+	INTERRUPT_IF_VCOUNTER_MATCH_Pos  = 0x2
+	INTERRUPT_IF_TIMER0_OVERFLOW_Pos = 0x3
+	INTERRUPT_IF_TIMER1_OVERFLOW_Pos = 0x4
+	INTERRUPT_IF_TIMER2_OVERFLOW_Pos = 0x5
+	INTERRUPT_IF_TIMER3_OVERFLOW_Pos = 0x6
+	INTERRUPT_IF_SERIAL_Pos          = 0x7
+	INTERRUPT_IF_DMA0_Pos            = 0x8
+	INTERRUPT_IF_DMA1_Pos            = 0x9
+	INTERRUPT_IF_DMA2_Pos            = 0xA
+	INTERRUPT_IF_DMA3_Pos            = 0xB
+	INTERRUPT_IF_KEYPAD_Pos          = 0xC
+	INTERRUPT_IF_GAMPAK_Pos          = 0xD
+)

src/examples/flash/main.go

@@ -0,0 +1,57 @@
+package main
+
+import (
+	"machine"
+	"time"
+)
+
+var (
+	err     error
+	message = "1234567887654321123456788765432112345678876543211234567887654321"
+)
+
+func main() {
+	time.Sleep(3 * time.Second)
+
+	// Print out general information
+	println("Flash data start:      ", machine.FlashDataStart())
+	println("Flash data end:        ", machine.FlashDataEnd())
+	println("Flash data size, bytes:", machine.Flash.Size())
+	println("Flash write block size:", machine.Flash.WriteBlockSize())
+	println("Flash erase block size:", machine.Flash.EraseBlockSize())
+	println()
+
+	flash := machine.OpenFlashBuffer(machine.Flash, machine.FlashDataStart())
+	original := make([]byte, len(message))
+	saved := make([]byte, len(message))
+
+	// Read flash contents on start (data shall survive power off)
+	print("Reading data from flash: ")
+	_, err = flash.Read(original)
+	checkError(err)
+	println(string(original))
+
+	// Write the message to flash
+	print("Writing data to flash: ")
+	flash.Seek(0, 0) // rewind back to beginning
+	_, err = flash.Write([]byte(message))
+	checkError(err)
+	println(string(message))
+
+	// Read back flash contents after write (verify data is the same as written)
+	print("Reading data back from flash: ")
+	flash.Seek(0, 0) // rewind back to beginning
+	_, err = flash.Read(saved)
+	checkError(err)
+	println(string(saved))
+	println()
+}
+
+func checkError(err error) {
+	if err != nil {
+		for {
+			println(err.Error())
+			time.Sleep(time.Second)
+		}
+	}
+}

src/examples/hid-keyboard/main.go

@@ -1,11 +1,22 @@
+// to override the USB Manufacturer or Product names:
+//
+// tinygo flash -target circuitplay-express -ldflags="-X main.usbManufacturer='TinyGopher Labs' -X main.usbProduct='GopherKeyboard'" examples/hid-keyboard
+//
+// you can also override the VID/PID. however, only set this if you know what you are doing,
+// since changing it can make it difficult to reflash some devices.
 package main
 
 import (
 	"machine"
+	"machine/usb"
 	"machine/usb/hid/keyboard"
+	"strconv"
 	"time"
 )
 
+var usbVID, usbPID string
+var usbManufacturer, usbProduct string
+
 func main() {
 	button := machine.BUTTON
 	button.Configure(machine.PinConfig{Mode: machine.PinInputPullup})
@@ -19,3 +30,23 @@ func main() {
 		}
 	}
 }
+
+func init() {
+	if usbVID != "" {
+		vid, _ := strconv.ParseUint(usbVID, 0, 16)
+		usb.VendorID = uint16(vid)
+	}
+
+	if usbPID != "" {
+		pid, _ := strconv.ParseUint(usbPID, 0, 16)
+		usb.ProductID = uint16(pid)
+	}
+
+	if usbManufacturer != "" {
+		usb.Manufacturer = usbManufacturer
+	}
+
+	if usbProduct != "" {
+		usb.Product = usbProduct
+	}
+}

src/examples/ram-func/main.go

@@ -0,0 +1,93 @@
+package main
+
+// This example demonstrates how to use go:section to place code into RAM for
+// execution.  The code is present in flash in the `.data` region and copied
+// into the correct place in RAM early in startup sequence (at the same time
+// as non-zero global variables are initialized).
+//
+// This example should work on any ARM Cortex MCU.
+//
+// For Go code use the pragma "//go:section", for cgo use the "section" and
+// "noinline" attributes.  The `.ramfuncs` section is explicitly placed into
+// the `.data` region by the linker script.
+//
+// Running the example should print out the program counter from the functions
+// below.  The program counters should be in different memory regions.
+//
+// On RP2040, for example, the output is something like this:
+//
+//  Go in RAM:    0x20000DB4
+//  Go in flash:  0x10007610
+//  cgo in RAM:   0x20000DB8
+//  cgo in flash: 0x10002C26
+//
+// This can be confirmed using `objdump -t xxx.elf | grep main | sort`:
+//
+//  00000000 l    df *ABS*  00000000 main
+//  1000760d l     F .text  00000004 main.in_flash
+//  10007611 l     F .text  0000000c __Thumbv6MABSLongThunk_main.in_ram
+//  1000761d l     F .text  0000000c __Thumbv6MABSLongThunk__Cgo_static_eea7585d7291176ad3bb_main_c_in_ram
+//  1000bdb5 l     O .text  00000013 main$string
+//  1000bdc8 l     O .text  00000013 main$string.1
+//  1000bddb l     O .text  00000013 main$string.2
+//  1000bdee l     O .text  00000013 main$string.3
+//  20000db1 l     F .data  00000004 main.in_ram
+//  20000db5 l     F .data  00000004 _Cgo_static_eea7585d7291176ad3bb_main_c_in_ram
+//
+
+import (
+	"device"
+	"fmt"
+	"time"
+	_ "unsafe" // unsafe is required for "//go:section"
+)
+
+/*
+	#define ram_func __attribute__((section(".ramfuncs"),noinline))
+
+	static ram_func void* main_c_in_ram() {
+		void* p = 0;
+
+		asm(
+			"MOV %0, PC"
+			: "=r"(p)
+		);
+
+		return p;
+	}
+
+	static void* main_c_in_flash() {
+		void* p = 0;
+
+		asm(
+			"MOV %0, PC"
+			: "=r"(p)
+		);
+
+		return p;
+	}
+*/
+import "C"
+
+func main() {
+	time.Sleep(2 * time.Second)
+
+	fmt.Printf("Go in RAM:    0x%X\n", in_ram())
+	fmt.Printf("Go in flash:  0x%X\n", in_flash())
+	fmt.Printf("cgo in RAM:   0x%X\n", C.main_c_in_ram())
+	fmt.Printf("cgo in flash: 0x%X\n", C.main_c_in_flash())
+}
+
+//go:section .ramfuncs
+func in_ram() uintptr {
+	return device.AsmFull("MOV {}, PC", nil)
+}
+
+// go:noinline used here to prevent function being 'inlined' into main()
+// so it appears in objdump output.  In normal use, go:inline is not
+// required for functions running from flash (flash is the default).
+//
+//go:noinline
+func in_flash() uintptr {
+	return device.AsmFull("MOV {}, PC", nil)
+}

src/examples/rtcinterrupt/rtcinterrupt.go

@@ -0,0 +1,35 @@
+//go:build rp2040
+
+package main
+
+// This example demonstrates scheduling a delayed interrupt by real time clock.
+//
+// An interrupt may execute user callback function or used for its side effects
+// like waking up from sleep or dormant states.
+//
+// The interrupt can be configured to repeat.
+//
+// There is no separate method to disable interrupt, use 0 delay for that.
+//
+// Unfortunately, it is not possible to use time.Duration to work with RTC directly,
+// that would introduce a circular dependency between "machine" and "time" packages.
+
+import (
+	"fmt"
+	"machine"
+	"time"
+)
+
+func main() {
+
+	// Schedule and enable recurring interrupt.
+	// The callback function is executed in the context of an interrupt handler,
+	// so regular restructions for this sort of code apply: no blocking, no memory allocation, etc.
+	delay := time.Minute + 12*time.Second
+	machine.RTC.SetInterrupt(uint32(delay.Seconds()), true, func() { println("Peekaboo!") })
+
+	for {
+		fmt.Printf("%v\r\n", time.Now().Format(time.RFC3339))
+		time.Sleep(1 * time.Second)
+	}
+}

src/internal/task/task_stack.go

@@ -2,7 +2,10 @@
 
 package task
 
-import "unsafe"
+import (
+	"runtime/interrupt"
+	"unsafe"
+)
 
 //go:linkname runtimePanic runtime.runtimePanic
 func runtimePanic(str string)
@@ -45,6 +48,9 @@ func Pause() {
 	if *currentTask.state.canaryPtr != stackCanary {
 		runtimePanic("goroutine stack overflow")
 	}
+	if interrupt.In() {
+		runtimePanic("blocked inside interrupt")
+	}
 	currentTask.state.pause()
 }
 

src/internal/task/task_stack_arm64.S

@@ -4,7 +4,6 @@ _tinygo_startTask:
 #else
 .section .text.tinygo_startTask
 .global  tinygo_startTask
-.type    tinygo_startTask, %function
 tinygo_startTask:
 #endif
     .cfi_startproc
@@ -35,7 +34,6 @@ tinygo_startTask:
 #endif
     .cfi_endproc
 #ifndef __MACH__
-.size tinygo_startTask, .-tinygo_startTask
 #endif
 
 
@@ -44,7 +42,6 @@ tinygo_startTask:
 _tinygo_swapTask:
 #else
 .global tinygo_swapTask
-.type tinygo_swapTask, %function
 tinygo_swapTask:
 #endif
     // This function gets the following parameters:
@@ -52,12 +49,16 @@ tinygo_swapTask:
     // x1 = oldStack *uintptr
 
     // Save all callee-saved registers:
-    stp     x19, x20, [sp, #-96]!
+    stp     x19, x20, [sp, #-160]!
     stp     x21, x22, [sp, #16]
     stp     x23, x24, [sp, #32]
     stp     x25, x26, [sp, #48]
     stp     x27, x28, [sp, #64]
     stp     x29, x30, [sp, #80]
+    stp     d8,  d9,  [sp, #96]
+    stp     d10, d11, [sp, #112]
+    stp     d12, d13, [sp, #128]
+    stp     d14, d15, [sp, #144]
 
     // Save the current stack pointer in oldStack.
     mov x8, sp
@@ -67,10 +68,14 @@ tinygo_swapTask:
     mov sp, x0
 
     // Restore stack state and return.
+    ldp     d14, d15, [sp, #144]
+    ldp     d12, d13, [sp, #128]
+    ldp     d10, d11, [sp, #112]
+    ldp     d8, d9, [sp, #96]
     ldp     x29, x30, [sp, #80]
     ldp     x27, x28, [sp, #64]
     ldp     x25, x26, [sp, #48]
     ldp     x23, x24, [sp, #32]
     ldp     x21, x22, [sp, #16]
-    ldp     x19, x20, [sp], #96
+    ldp     x19, x20, [sp], #160
     ret

src/internal/task/task_stack_arm64.go

@@ -1,4 +1,4 @@
-//go:build scheduler.tasks && arm64 && !windows
+//go:build scheduler.tasks && arm64
 
 package task
 
@@ -21,8 +21,16 @@ type calleeSavedRegs struct {
 	x27 uintptr
 	x28 uintptr
 	x29 uintptr
+	pc  uintptr // aka x30 aka LR
 
-	pc uintptr // aka x30 aka LR
+	d8  uintptr
+	d9  uintptr
+	d10 uintptr
+	d11 uintptr
+	d12 uintptr
+	d13 uintptr
+	d14 uintptr
+	d15 uintptr
 }
 
 // archInit runs architecture-specific setup for the goroutine startup.

src/internal/task/task_stack_arm64_windows.S

@@ -1,65 +0,0 @@
-.section .text.tinygo_startTask,"ax"
-.global  tinygo_startTask
-tinygo_startTask:
-    .cfi_startproc
-    // Small assembly stub for starting a goroutine. This is already run on the
-    // new stack, with the callee-saved registers already loaded.
-    // Most importantly, x19 contains the pc of the to-be-started function and
-    // x20 contains the only argument it is given. Multiple arguments are packed
-    // into one by storing them in a new allocation.
-
-    // Indicate to the unwinder that there is nothing to unwind, this is the
-    // root frame. It avoids the following (bogus) error message in GDB:
-    //     Backtrace stopped: previous frame identical to this frame (corrupt stack?)
-    .cfi_undefined lr
-
-    // Set the first argument of the goroutine start wrapper, which contains all
-    // the arguments.
-    mov   x0, x20
-
-    // Branch to the "goroutine start" function. By using blx instead of bx,
-    // we'll return here instead of tail calling.
-    blr   x19
-
-    // After return, exit this goroutine. This is a tail call.
-    b     tinygo_pause
-    .cfi_endproc
-
-
-.global tinygo_swapTask
-tinygo_swapTask:
-    // This function gets the following parameters:
-    // x0 = newStack uintptr
-    // x1 = oldStack *uintptr
-
-    // Save all callee-saved registers:
-    stp     x19, x20, [sp, #-160]!
-    stp     x21, x22, [sp, #16]
-    stp     x23, x24, [sp, #32]
-    stp     x25, x26, [sp, #48]
-    stp     x27, x28, [sp, #64]
-    stp     x29, x30, [sp, #80]
-    stp     d8,  d9,  [sp, #96]
-    stp     d10, d11, [sp, #112]
-    stp     d12, d13, [sp, #128]
-    stp     d14, d15, [sp, #144]
-
-    // Save the current stack pointer in oldStack.
-    mov x8, sp
-    str x8, [x1]
-
-    // Switch to the new stack pointer.
-    mov sp, x0
-
-    // Restore stack state and return.
-    ldp     d14, d15, [sp, #144]
-    ldp     d12, d13, [sp, #128]
-    ldp     d10, d11, [sp, #112]
-    ldp     d8, d9, [sp, #96]
-    ldp     x29, x30, [sp, #80]
-    ldp     x27, x28, [sp, #64]
-    ldp     x25, x26, [sp, #48]
-    ldp     x23, x24, [sp, #32]
-    ldp     x21, x22, [sp, #16]
-    ldp     x19, x20, [sp], #160
-    ret

src/internal/task/task_stack_arm64_windows.go

@@ -1,72 +0,0 @@
-//go:build scheduler.tasks && arm64 && windows
-
-package task
-
-import "unsafe"
-
-var systemStack uintptr
-
-// calleeSavedRegs is the list of registers that must be saved and restored
-// when switching between tasks. Also see task_stack_arm64_windows.S that
-// relies on the exact layout of this struct.
-type calleeSavedRegs struct {
-	x19 uintptr
-	x20 uintptr
-	x21 uintptr
-	x22 uintptr
-	x23 uintptr
-	x24 uintptr
-	x25 uintptr
-	x26 uintptr
-	x27 uintptr
-	x28 uintptr
-	x29 uintptr
-	pc  uintptr // aka x30 aka LR
-
-	d8  uintptr
-	d9  uintptr
-	d10 uintptr
-	d11 uintptr
-	d12 uintptr
-	d13 uintptr
-	d14 uintptr
-	d15 uintptr
-}
-
-// archInit runs architecture-specific setup for the goroutine startup.
-func (s *state) archInit(r *calleeSavedRegs, fn uintptr, args unsafe.Pointer) {
-	// Store the initial sp for the startTask function (implemented in assembly).
-	s.sp = uintptr(unsafe.Pointer(r))
-
-	// Initialize the registers.
-	// These will be popped off of the stack on the first resume of the goroutine.
-
-	// Start the function at tinygo_startTask (defined in src/internal/task/task_stack_arm64_windows.S).
-	// This assembly code calls a function (passed in x19) with a single argument
-	// (passed in x20). After the function returns, it calls Pause().
-	r.pc = uintptr(unsafe.Pointer(&startTask))
-
-	// Pass the function to call in x19.
-	// This function is a compiler-generated wrapper which loads arguments out of a struct pointer.
-	// See createGoroutineStartWrapper (defined in compiler/goroutine.go) for more information.
-	r.x19 = fn
-
-	// Pass the pointer to the arguments struct in x20.
-	r.x20 = uintptr(args)
-}
-
-func (s *state) resume() {
-	swapTask(s.sp, &systemStack)
-}
-
-func (s *state) pause() {
-	newStack := systemStack
-	systemStack = 0
-	swapTask(newStack, &s.sp)
-}
-
-// SystemStack returns the system stack pointer when called from a task stack.
-// When called from the system stack, it returns 0.
-func SystemStack() uintptr {
-	return systemStack
-}

src/internal/task/task_stack_cortexm.c

@@ -0,0 +1,13 @@
+//go:build scheduler.tasks && cortexm
+#include <stdint.h>
+
+uintptr_t SystemStack() {
+    uintptr_t sp;
+    asm volatile(
+        "mrs %0, MSP"
+        : "=r"(sp)
+        :
+        : "memory"
+    );
+    return sp;
+}

src/internal/task/task_stack_cortexm.go

@@ -8,8 +8,8 @@ package task
 // PSP, which is used for goroutines) so that goroutines do not need extra stack
 // space for interrupts.
 
+import "C"
 import (
-	"device/arm"
 	"unsafe"
 )
 
@@ -67,6 +67,6 @@ func (s *state) pause() {
 
 // SystemStack returns the system stack pointer. On Cortex-M, it is always
 // available.
-func SystemStack() uintptr {
-	return arm.AsmFull("mrs {}, MSP", nil)
-}
+//
+//export SystemStack
+func SystemStack() uintptr

src/machine/board_gopher-badge.go

@@ -0,0 +1,108 @@
+//go:build gopher_badge
+
+// This contains the pin mappings for the Gopher Badge.
+//
+// For more information, see: https://gopherbadge.com/
+package machine
+
+import (
+	"device/rp"
+	"runtime/interrupt"
+)
+
+const (
+	/*ADC0 Pin = GPIO26
+	ADC1 Pin = GPIO27
+	ADC2 Pin = GPIO28
+	GPIO4 Pin = GPIO4
+	GPIO5 Pin = GPIO5
+	GPIO6 Pin = GPIO6
+	GPIO7 Pin = GPIO7
+	GPIO8 Pin = GPIO8
+	GPIO9 Pin = GPIO9*/
+
+	PENIRQ Pin = GPIO13
+
+	LED       Pin = GPIO2
+	NEOPIXELS Pin = GPIO15
+	WS2812    Pin = GPIO15
+
+	BUTTON_A     Pin = GPIO10
+	BUTTON_B     Pin = GPIO11
+	BUTTON_LEFT  Pin = GPIO25
+	BUTTON_UP    Pin = GPIO24
+	BUTTON_RIGHT Pin = GPIO22
+	BUTTON_DOWN  Pin = GPIO23
+
+	TFT_RST       Pin = GPIO21
+	TFT_SDI       Pin = GPIO19
+	TFT_SDO       Pin = GPIO16
+	TFT_CS        Pin = GPIO17
+	TFT_SCL       Pin = GPIO18
+	TFT_WRX       Pin = GPIO20
+	TFT_BACKLIGHT Pin = GPIO12
+
+	SPEAKER        Pin = GPIO14
+	SPEAKER_ENABLE Pin = GPIO3
+)
+
+// I2C pins
+const (
+	I2C0_SDA_PIN Pin = GPIO0
+	I2C0_SCL_PIN Pin = GPIO1
+
+	I2C1_SDA_PIN Pin = NoPin
+	I2C1_SCL_PIN Pin = NoPin
+)
+
+// SPI pins.
+const (
+	SPI0_SCK_PIN Pin = GPIO18
+	SPI0_SDO_PIN Pin = GPIO19
+	SPI0_SDI_PIN Pin = GPIO16
+
+	SPI1_SCK_PIN Pin = NoPin
+	SPI1_SDO_PIN Pin = NoPin
+	SPI1_SDI_PIN Pin = NoPin
+)
+
+// Onboard crystal oscillator frequency, in MHz.
+const (
+	xoscFreq = 12 // MHz
+)
+
+// USB CDC identifiers
+const (
+	usb_STRING_PRODUCT      = "Gopher Badger"
+	usb_STRING_MANUFACTURER = "TinyGo"
+)
+
+var (
+	usb_VID uint16 = 0x2e8a
+	usb_PID uint16 = 0x0003
+)
+
+// UART pins
+const (
+	UART0_TX_PIN = GPIO0
+	UART0_RX_PIN = GPIO1
+	UART1_TX_PIN = GPIO4
+	UART1_RX_PIN = GPIO5
+	UART_TX_PIN  = UART0_TX_PIN
+	UART_RX_PIN  = UART0_RX_PIN
+)
+
+// UART on the RP2040
+var (
+	UART1  = &_UART1
+	_UART1 = UART{
+		Buffer: NewRingBuffer(),
+		Bus:    rp.UART1,
+	}
+)
+
+var DefaultUART = UART1
+
+func init() {
+	UART1.Interrupt = interrupt.New(rp.IRQ_UART1_IRQ, _UART1.handleInterrupt)
+}

src/machine/board_lorae5.go

@@ -10,6 +10,14 @@ import (
 const (
 	// We assume a LED is connected on PB5
 	LED = PB5 // Default LED
+
+	// Set the POWER_EN3V3 pin to high to turn
+	// on the 3.3V power for all peripherals
+	POWER_EN3V3 = PA9
+
+	// Set the POWER_EN5V pin to high to turn
+	// on the 5V bus power for all peripherals
+	POWER_EN5V = PB10
 )
 
 // SubGhz (SPI3)
@@ -22,11 +30,11 @@ const (
 
 // UARTS
 const (
-	//MCU USART1
+	// MCU USART1
 	UART1_TX_PIN = PB6
 	UART1_RX_PIN = PB7
 
-	//MCU USART2
+	// MCU USART2
 	UART2_TX_PIN = PA2
 	UART2_RX_PIN = PA3
 
@@ -34,15 +42,14 @@ const (
 	UART_TX_PIN = UART1_TX_PIN
 	UART_RX_PIN = UART1_RX_PIN
 
-	// I2C1 pins
-	// I2C1 is connected to Flash, Accelerometer, Env. Sensor, Crypto Element)
-	I2C1_SCL_PIN  = PA9
-	I2C1_SDA_PIN  = PA10
-	I2C1_ALT_FUNC = 4
+	// I2C2 pins
+	I2C2_SCL_PIN  = PB15
+	I2C2_SDA_PIN  = PA15
+	I2C2_ALT_FUNC = 4
 
-	// I2C0 alias for I2C1
-	I2C0_SDA_PIN = I2C1_SDA_PIN
-	I2C0_SCL_PIN = I2C1_SCL_PIN
+	// I2C0 alias for I2C2
+	I2C0_SDA_PIN = I2C2_SDA_PIN
+	I2C0_SCL_PIN = I2C2_SCL_PIN
 )
 
 var (
@@ -56,13 +63,27 @@ var (
 	}
 	DefaultUART = UART0
 
-	// I2C Busses
-	I2C1 = &I2C{
-		Bus:             stm32.I2C1,
-		AltFuncSelector: I2C1_ALT_FUNC,
+	// Since we treat UART1 as zero, let's also call it by the real name
+	UART1 = UART0
+
+	// UART2
+	UART2  = &_UART2
+	_UART2 = UART{
+		Buffer:            NewRingBuffer(),
+		Bus:               stm32.USART2,
+		TxAltFuncSelector: AF7_USART1_2,
+		RxAltFuncSelector: AF7_USART1_2,
 	}
 
-	I2C0 = I2C1
+	// I2C Busses
+	I2C2 = &I2C{
+		Bus:             stm32.I2C2,
+		AltFuncSelector: I2C2_ALT_FUNC,
+	}
+
+	// Set "default" I2C bus to I2C2
+	I2C0 = I2C2
+
 	// SPI
 	SPI3 = SPI{
 		Bus: stm32.SPI3,
@@ -72,4 +93,5 @@ var (
 func init() {
 	// Enable UARTs Interrupts
 	UART0.Interrupt = interrupt.New(stm32.IRQ_USART1, _UART0.handleInterrupt)
+	UART2.Interrupt = interrupt.New(stm32.IRQ_USART2, _UART2.handleInterrupt)
 }

src/machine/board_qtpy.go

@@ -29,7 +29,7 @@ const (
 
 // Analog pins
 const (
-	A0 = D1
+	A0 = D0
 	A1 = D1
 	A2 = D2
 	A3 = D3

src/machine/board_wioterminal.go

@@ -90,7 +90,7 @@ const (
 	BCM10 = PB02 // SPI SDO
 	BCM11 = PB03 // SPI SCK
 	BCM12 = PB06
-	BCM13 = PA07
+	BCM13 = PA04
 	BCM14 = PB27 // UART Serial1
 	BCM15 = PB26 // UART Serial1
 	BCM16 = PB07

src/machine/board_xiao-rp2040.go

@@ -50,11 +50,11 @@ const (
 
 // I2C pins
 const (
-	I2C0_SDA_PIN Pin = D4
-	I2C0_SCL_PIN Pin = D5
+	I2C0_SDA_PIN Pin = D2
+	I2C0_SCL_PIN Pin = D3
 
-	I2C1_SDA_PIN Pin = NoPin
-	I2C1_SCL_PIN Pin = NoPin
+	I2C1_SDA_PIN Pin = D4
+	I2C1_SCL_PIN Pin = D5
 )
 
 // SPI pins

src/machine/flash.go

@@ -0,0 +1,145 @@
+//go:build nrf || nrf51 || nrf52 || nrf528xx || stm32f4 || stm32l4 || stm32wlx || atsamd21 || atsamd51 || atsame5x || rp2040
+
+package machine
+
+import (
+	"errors"
+	"io"
+	"unsafe"
+)
+
+//go:extern __flash_data_start
+var flashDataStart [0]byte
+
+//go:extern __flash_data_end
+var flashDataEnd [0]byte
+
+// Return the start of the writable flash area, aligned on a page boundary. This
+// is usually just after the program and static data.
+func FlashDataStart() uintptr {
+	pagesize := uintptr(eraseBlockSize())
+	return (uintptr(unsafe.Pointer(&flashDataStart)) + pagesize - 1) &^ (pagesize - 1)
+}
+
+// Return the end of the writable flash area. Usually this is the address one
+// past the end of the on-chip flash.
+func FlashDataEnd() uintptr {
+	return uintptr(unsafe.Pointer(&flashDataEnd))
+}
+
+var (
+	errFlashCannotErasePage     = errors.New("cannot erase flash page")
+	errFlashInvalidWriteLength  = errors.New("write flash data must align to correct number of bits")
+	errFlashNotAllowedWriteData = errors.New("not allowed to write flash data")
+	errFlashCannotWriteData     = errors.New("cannot write flash data")
+	errFlashCannotReadPastEOF   = errors.New("cannot read beyond end of flash data")
+	errFlashCannotWritePastEOF  = errors.New("cannot write beyond end of flash data")
+	errFlashCannotErasePastEOF  = errors.New("cannot erase beyond end of flash data")
+)
+
+// BlockDevice is the raw device that is meant to store flash data.
+type BlockDevice interface {
+	// ReadAt reads the given number of bytes from the block device.
+	io.ReaderAt
+
+	// WriteAt writes the given number of bytes to the block device.
+	io.WriterAt
+
+	// Size returns the number of bytes in this block device.
+	Size() int64
+
+	// WriteBlockSize returns the block size in which data can be written to
+	// memory. It can be used by a client to optimize writes, non-aligned writes
+	// should always work correctly.
+	WriteBlockSize() int64
+
+	// EraseBlockSize returns the smallest erasable area on this particular chip
+	// in bytes. This is used for the block size in EraseBlocks.
+	// It must be a power of two, and may be as small as 1. A typical size is 4096.
+	EraseBlockSize() int64
+
+	// EraseBlocks erases the given number of blocks. An implementation may
+	// transparently coalesce ranges of blocks into larger bundles if the chip
+	// supports this. The start and len parameters are in block numbers, use
+	// EraseBlockSize to map addresses to blocks.
+	EraseBlocks(start, len int64) error
+}
+
+// FlashBuffer implements the ReadWriteCloser interface using the BlockDevice interface.
+type FlashBuffer struct {
+	b BlockDevice
+
+	// start is actual address
+	start uintptr
+
+	// offset is relative to start
+	offset uintptr
+}
+
+// OpenFlashBuffer opens a FlashBuffer.
+func OpenFlashBuffer(b BlockDevice, address uintptr) *FlashBuffer {
+	return &FlashBuffer{b: b, start: address}
+}
+
+// Read data from a FlashBuffer.
+func (fl *FlashBuffer) Read(p []byte) (n int, err error) {
+	n, err = fl.b.ReadAt(p, int64(fl.offset))
+	fl.offset += uintptr(n)
+
+	return
+}
+
+// Write data to a FlashBuffer.
+func (fl *FlashBuffer) Write(p []byte) (n int, err error) {
+	// any new pages needed?
+	// NOTE probably will not work as expected if you try to write over page boundary
+	// of pages with different sizes.
+	pagesize := uintptr(fl.b.EraseBlockSize())
+
+	// calculate currentPageBlock relative to fl.start, meaning that
+	// block 0 -> fl.start
+	// block 1 -> fl.start + pagesize
+	// block 2 -> fl.start + pagesize*2
+	// ...
+	currentPageBlock := (fl.start + fl.offset - FlashDataStart()) + (pagesize-1)/pagesize
+	lastPageBlockNeeded := (fl.start + fl.offset + uintptr(len(p)) - FlashDataStart()) + (pagesize-1)/pagesize
+
+	// erase enough blocks to hold the data
+	if err := fl.b.EraseBlocks(int64(currentPageBlock), int64(lastPageBlockNeeded-currentPageBlock)); err != nil {
+		return 0, err
+	}
+
+	// write the data
+	for i := 0; i < len(p); i += int(pagesize) {
+		var last int = i + int(pagesize)
+		if i+int(pagesize) > len(p) {
+			last = len(p)
+		}
+
+		_, err := fl.b.WriteAt(p[i:last], int64(fl.offset))
+		if err != nil {
+			return 0, err
+		}
+		fl.offset += uintptr(len(p[i:last]))
+	}
+
+	return len(p), nil
+}
+
+// Close the FlashBuffer.
+func (fl *FlashBuffer) Close() error {
+	return nil
+}
+
+// Seek implements io.Seeker interface, but with limitations.
+// You can only seek relative to the start.
+// Also, you cannot use seek before write operations, only read.
+func (fl *FlashBuffer) Seek(offset int64, whence int) (int64, error) {
+	if whence != io.SeekStart {
+		panic("you can only Seek relative to Start")
+	}
+
+	fl.offset = uintptr(offset)
+
+	return offset, nil
+}

src/machine/machine_atsamd21.go

@@ -7,8 +7,11 @@
 package machine
 
 import (
+	"bytes"
 	"device/arm"
 	"device/sam"
+	"encoding/binary"
+	"errors"
 	"runtime/interrupt"
 	"unsafe"
 )
@@ -1788,3 +1791,167 @@ func syncDAC() {
 	for sam.DAC.STATUS.HasBits(sam.DAC_STATUS_SYNCBUSY) {
 	}
 }
+
+// Flash related code
+const memoryStart = 0x0
+
+// compile-time check for ensuring we fulfill BlockDevice interface
+var _ BlockDevice = flashBlockDevice{}
+
+var Flash flashBlockDevice
+
+type flashBlockDevice struct {
+	initComplete bool
+}
+
+// ReadAt reads the given number of bytes from the block device.
+func (f flashBlockDevice) ReadAt(p []byte, off int64) (n int, err error) {
+	if FlashDataStart()+uintptr(off)+uintptr(len(p)) > FlashDataEnd() {
+		return 0, errFlashCannotReadPastEOF
+	}
+
+	f.ensureInitComplete()
+
+	waitWhileFlashBusy()
+
+	data := unsafe.Slice((*byte)(unsafe.Add(unsafe.Pointer(FlashDataStart()), uintptr(off))), len(p))
+	copy(p, data)
+
+	return len(p), nil
+}
+
+// WriteAt writes the given number of bytes to the block device.
+// Only word (32 bits) length data can be programmed.
+// See Atmel-42181G–SAM-D21_Datasheet–09/2015 page 359.
+// If the length of p is not long enough it will be padded with 0xFF bytes.
+// This method assumes that the destination is already erased.
+func (f flashBlockDevice) WriteAt(p []byte, off int64) (n int, err error) {
+	if FlashDataStart()+uintptr(off)+uintptr(len(p)) > FlashDataEnd() {
+		return 0, errFlashCannotWritePastEOF
+	}
+
+	f.ensureInitComplete()
+
+	address := FlashDataStart() + uintptr(off)
+	padded := f.pad(p)
+
+	waitWhileFlashBusy()
+
+	for j := 0; j < len(padded); j += int(f.WriteBlockSize()) {
+		// write word
+		*(*uint32)(unsafe.Pointer(address)) = binary.LittleEndian.Uint32(padded[j : j+int(f.WriteBlockSize())])
+
+		sam.NVMCTRL.SetADDR(uint32(address >> 1))
+		sam.NVMCTRL.CTRLA.Set(sam.NVMCTRL_CTRLA_CMD_WP | (sam.NVMCTRL_CTRLA_CMDEX_KEY << sam.NVMCTRL_CTRLA_CMDEX_Pos))
+
+		waitWhileFlashBusy()
+
+		if err := checkFlashError(); err != nil {
+			return j, err
+		}
+
+		address += uintptr(f.WriteBlockSize())
+	}
+
+	return len(padded), nil
+}
+
+// Size returns the number of bytes in this block device.
+func (f flashBlockDevice) Size() int64 {
+	return int64(FlashDataEnd() - FlashDataStart())
+}
+
+const writeBlockSize = 4
+
+// WriteBlockSize returns the block size in which data can be written to
+// memory. It can be used by a client to optimize writes, non-aligned writes
+// should always work correctly.
+func (f flashBlockDevice) WriteBlockSize() int64 {
+	return writeBlockSize
+}
+
+const eraseBlockSizeValue = 256
+
+func eraseBlockSize() int64 {
+	return eraseBlockSizeValue
+}
+
+// EraseBlockSize returns the smallest erasable area on this particular chip
+// in bytes. This is used for the block size in EraseBlocks.
+func (f flashBlockDevice) EraseBlockSize() int64 {
+	return eraseBlockSize()
+}
+
+// EraseBlocks erases the given number of blocks. An implementation may
+// transparently coalesce ranges of blocks into larger bundles if the chip
+// supports this. The start and len parameters are in block numbers, use
+// EraseBlockSize to map addresses to blocks.
+func (f flashBlockDevice) EraseBlocks(start, len int64) error {
+	f.ensureInitComplete()
+
+	address := FlashDataStart() + uintptr(start*f.EraseBlockSize())
+	waitWhileFlashBusy()
+
+	for i := start; i < start+len; i++ {
+		sam.NVMCTRL.SetADDR(uint32(address >> 1))
+		sam.NVMCTRL.CTRLA.Set(sam.NVMCTRL_CTRLA_CMD_ER | (sam.NVMCTRL_CTRLA_CMDEX_KEY << sam.NVMCTRL_CTRLA_CMDEX_Pos))
+
+		waitWhileFlashBusy()
+
+		if err := checkFlashError(); err != nil {
+			return err
+		}
+
+		address += uintptr(f.EraseBlockSize())
+	}
+
+	return nil
+}
+
+// pad data if needed so it is long enough for correct byte alignment on writes.
+func (f flashBlockDevice) pad(p []byte) []byte {
+	paddingNeeded := f.WriteBlockSize() - (int64(len(p)) % f.WriteBlockSize())
+	if paddingNeeded == 0 {
+		return p
+	}
+
+	padding := bytes.Repeat([]byte{0xff}, int(paddingNeeded))
+	return append(p, padding...)
+}
+
+func (f flashBlockDevice) ensureInitComplete() {
+	if f.initComplete {
+		return
+	}
+
+	sam.NVMCTRL.SetCTRLB_READMODE(sam.NVMCTRL_CTRLB_READMODE_NO_MISS_PENALTY)
+	sam.NVMCTRL.SetCTRLB_SLEEPPRM(sam.NVMCTRL_CTRLB_SLEEPPRM_WAKEONACCESS)
+
+	waitWhileFlashBusy()
+
+	f.initComplete = true
+}
+
+func waitWhileFlashBusy() {
+	for sam.NVMCTRL.GetINTFLAG_READY() != sam.NVMCTRL_INTFLAG_READY {
+	}
+}
+
+var (
+	errFlashPROGE = errors.New("errFlashPROGE")
+	errFlashLOCKE = errors.New("errFlashLOCKE")
+	errFlashNVME  = errors.New("errFlashNVME")
+)
+
+func checkFlashError() error {
+	switch {
+	case sam.NVMCTRL.GetSTATUS_PROGE() != 0:
+		return errFlashPROGE
+	case sam.NVMCTRL.GetSTATUS_LOCKE() != 0:
+		return errFlashLOCKE
+	case sam.NVMCTRL.GetSTATUS_NVME() != 0:
+		return errFlashNVME
+	}
+
+	return nil
+}

src/machine/machine_atsamd21g18.go

@@ -406,61 +406,61 @@ func (p Pin) getPinCfg() uint8 {
 		return uint8(sam.PORT.PINCFG1_0.Get()>>16) & 0xff
 	case 35: // PB03
 		return uint8(sam.PORT.PINCFG1_0.Get()>>24) & 0xff
-	case 37: // PB04
+	case 36: // PB04
 		return uint8(sam.PORT.PINCFG1_4.Get()>>0) & 0xff
-	case 38: // PB05
+	case 37: // PB05
 		return uint8(sam.PORT.PINCFG1_4.Get()>>8) & 0xff
-	case 39: // PB06
+	case 38: // PB06
 		return uint8(sam.PORT.PINCFG1_4.Get()>>16) & 0xff
-	case 40: // PB07
+	case 39: // PB07
 		return uint8(sam.PORT.PINCFG1_4.Get()>>24) & 0xff
-	case 41: // PB08
+	case 40: // PB08
 		return uint8(sam.PORT.PINCFG1_8.Get()>>0) & 0xff
-	case 42: // PB09
+	case 41: // PB09
 		return uint8(sam.PORT.PINCFG1_8.Get()>>8) & 0xff
-	case 43: // PB10
+	case 42: // PB10
 		return uint8(sam.PORT.PINCFG1_8.Get()>>16) & 0xff
-	case 44: // PB11
+	case 43: // PB11
 		return uint8(sam.PORT.PINCFG1_8.Get()>>24) & 0xff
-	case 45: // PB12
+	case 44: // PB12
 		return uint8(sam.PORT.PINCFG1_12.Get()>>0) & 0xff
-	case 46: // PB13
+	case 45: // PB13
 		return uint8(sam.PORT.PINCFG1_12.Get()>>8) & 0xff
-	case 47: // PB14
+	case 46: // PB14
 		return uint8(sam.PORT.PINCFG1_12.Get()>>16) & 0xff
-	case 48: // PB15
+	case 47: // PB15
 		return uint8(sam.PORT.PINCFG1_12.Get()>>24) & 0xff
-	case 49: // PB16
+	case 48: // PB16
 		return uint8(sam.PORT.PINCFG1_16.Get()>>0) & 0xff
-	case 50: // PB17
+	case 49: // PB17
 		return uint8(sam.PORT.PINCFG1_16.Get()>>8) & 0xff
-	case 51: // PB18
+	case 50: // PB18
 		return uint8(sam.PORT.PINCFG1_16.Get()>>16) & 0xff
-	case 52: // PB19
+	case 51: // PB19
 		return uint8(sam.PORT.PINCFG1_16.Get()>>24) & 0xff
-	case 53: // PB20
+	case 52: // PB20
 		return uint8(sam.PORT.PINCFG1_20.Get()>>0) & 0xff
-	case 54: // PB21
+	case 53: // PB21
 		return uint8(sam.PORT.PINCFG1_20.Get()>>8) & 0xff
-	case 55: // PB22
+	case 54: // PB22
 		return uint8(sam.PORT.PINCFG1_20.Get()>>16) & 0xff
-	case 56: // PB23
+	case 55: // PB23
 		return uint8(sam.PORT.PINCFG1_20.Get()>>24) & 0xff
-	case 57: // PB24
+	case 56: // PB24
 		return uint8(sam.PORT.PINCFG1_24.Get()>>0) & 0xff
-	case 58: // PB25
+	case 57: // PB25
 		return uint8(sam.PORT.PINCFG1_24.Get()>>8) & 0xff
-	case 59: // PB26
+	case 58: // PB26
 		return uint8(sam.PORT.PINCFG1_24.Get()>>16) & 0xff
-	case 60: // PB27
+	case 59: // PB27
 		return uint8(sam.PORT.PINCFG1_24.Get()>>24) & 0xff
-	case 61: // PB28
+	case 60: // PB28
 		return uint8(sam.PORT.PINCFG1_28.Get()>>0) & 0xff
-	case 62: // PB29
+	case 61: // PB29
 		return uint8(sam.PORT.PINCFG1_28.Get()>>8) & 0xff
-	case 63: // PB30
+	case 62: // PB30
 		return uint8(sam.PORT.PINCFG1_28.Get()>>16) & 0xff
-	case 64: // PB31
+	case 63: // PB31
 		return uint8(sam.PORT.PINCFG1_28.Get()>>24) & 0xff
 	default:
 		return 0

src/machine/machine_atsamd51.go

@@ -7,8 +7,11 @@
 package machine
 
 import (
+	"bytes"
 	"device/arm"
 	"device/sam"
+	"encoding/binary"
+	"errors"
 	"runtime/interrupt"
 	"unsafe"
 )
@@ -2074,3 +2077,190 @@ func GetRNG() (uint32, error) {
 	ret := sam.TRNG.DATA.Get()
 	return ret, nil
 }
+
+// Flash related code
+const memoryStart = 0x0
+
+// compile-time check for ensuring we fulfill BlockDevice interface
+var _ BlockDevice = flashBlockDevice{}
+
+var Flash flashBlockDevice
+
+type flashBlockDevice struct {
+	initComplete bool
+}
+
+// ReadAt reads the given number of bytes from the block device.
+func (f flashBlockDevice) ReadAt(p []byte, off int64) (n int, err error) {
+	if FlashDataStart()+uintptr(off)+uintptr(len(p)) > FlashDataEnd() {
+		return 0, errFlashCannotReadPastEOF
+	}
+
+	waitWhileFlashBusy()
+
+	data := unsafe.Slice((*byte)(unsafe.Add(unsafe.Pointer(FlashDataStart()), uintptr(off))), len(p))
+	copy(p, data)
+
+	return len(p), nil
+}
+
+// WriteAt writes the given number of bytes to the block device.
+// Only word (32 bits) length data can be programmed.
+// See SAM-D5x-E5x-Family-Data-Sheet-DS60001507.pdf page 591-592.
+// If the length of p is not long enough it will be padded with 0xFF bytes.
+// This method assumes that the destination is already erased.
+func (f flashBlockDevice) WriteAt(p []byte, off int64) (n int, err error) {
+	if FlashDataStart()+uintptr(off)+uintptr(len(p)) > FlashDataEnd() {
+		return 0, errFlashCannotWritePastEOF
+	}
+
+	address := FlashDataStart() + uintptr(off)
+	padded := f.pad(p)
+
+	settings := disableFlashCache()
+	defer restoreFlashCache(settings)
+
+	waitWhileFlashBusy()
+
+	sam.NVMCTRL.CTRLB.Set(sam.NVMCTRL_CTRLB_CMD_PBC | (sam.NVMCTRL_CTRLB_CMDEX_KEY << sam.NVMCTRL_CTRLB_CMDEX_Pos))
+
+	waitWhileFlashBusy()
+
+	for j := 0; j < len(padded); j += int(f.WriteBlockSize()) {
+		// write first word using double-word low order word
+		*(*uint32)(unsafe.Pointer(address)) = binary.LittleEndian.Uint32(padded[j : j+int(f.WriteBlockSize()/2)])
+
+		// write second word using double-word high order word
+		*(*uint32)(unsafe.Add(unsafe.Pointer(address), uintptr(f.WriteBlockSize())/2)) = binary.LittleEndian.Uint32(padded[j+int(f.WriteBlockSize()/2) : j+int(f.WriteBlockSize())])
+
+		waitWhileFlashBusy()
+
+		sam.NVMCTRL.SetADDR(uint32(address))
+		sam.NVMCTRL.CTRLB.Set(sam.NVMCTRL_CTRLB_CMD_WQW | (sam.NVMCTRL_CTRLB_CMDEX_KEY << sam.NVMCTRL_CTRLB_CMDEX_Pos))
+
+		waitWhileFlashBusy()
+
+		if err := checkFlashError(); err != nil {
+			return j, err
+		}
+
+		address += uintptr(f.WriteBlockSize())
+	}
+
+	return len(padded), nil
+}
+
+// Size returns the number of bytes in this block device.
+func (f flashBlockDevice) Size() int64 {
+	return int64(FlashDataEnd() - FlashDataStart())
+}
+
+const writeBlockSize = 8
+
+// WriteBlockSize returns the block size in which data can be written to
+// memory. It can be used by a client to optimize writes, non-aligned writes
+// should always work correctly.
+func (f flashBlockDevice) WriteBlockSize() int64 {
+	return writeBlockSize
+}
+
+const eraseBlockSizeValue = 8192
+
+func eraseBlockSize() int64 {
+	return eraseBlockSizeValue
+}
+
+// EraseBlockSize returns the smallest erasable area on this particular chip
+// in bytes. This is used for the block size in EraseBlocks.
+func (f flashBlockDevice) EraseBlockSize() int64 {
+	return eraseBlockSize()
+}
+
+// EraseBlocks erases the given number of blocks. An implementation may
+// transparently coalesce ranges of blocks into larger bundles if the chip
+// supports this. The start and len parameters are in block numbers, use
+// EraseBlockSize to map addresses to blocks.
+func (f flashBlockDevice) EraseBlocks(start, len int64) error {
+	address := FlashDataStart() + uintptr(start*f.EraseBlockSize())
+
+	settings := disableFlashCache()
+	defer restoreFlashCache(settings)
+
+	waitWhileFlashBusy()
+
+	for i := start; i < start+len; i++ {
+		sam.NVMCTRL.SetADDR(uint32(address))
+		sam.NVMCTRL.CTRLB.Set(sam.NVMCTRL_CTRLB_CMD_EB | (sam.NVMCTRL_CTRLB_CMDEX_KEY << sam.NVMCTRL_CTRLB_CMDEX_Pos))
+
+		waitWhileFlashBusy()
+
+		if err := checkFlashError(); err != nil {
+			return err
+		}
+
+		address += uintptr(f.EraseBlockSize())
+	}
+
+	return nil
+}
+
+// pad data if needed so it is long enough for correct byte alignment on writes.
+func (f flashBlockDevice) pad(p []byte) []byte {
+	paddingNeeded := f.WriteBlockSize() - (int64(len(p)) % f.WriteBlockSize())
+	if paddingNeeded == 0 {
+		return p
+	}
+
+	padding := bytes.Repeat([]byte{0xff}, int(paddingNeeded))
+	return append(p, padding...)
+}
+
+func disableFlashCache() uint16 {
+	settings := sam.NVMCTRL.CTRLA.Get()
+
+	// disable caches
+	sam.NVMCTRL.SetCTRLA_CACHEDIS0(1)
+	sam.NVMCTRL.SetCTRLA_CACHEDIS1(1)
+
+	waitWhileFlashBusy()
+
+	return settings
+}
+
+func restoreFlashCache(settings uint16) {
+	sam.NVMCTRL.CTRLA.Set(settings)
+	waitWhileFlashBusy()
+}
+
+func waitWhileFlashBusy() {
+	for sam.NVMCTRL.GetSTATUS_READY() != sam.NVMCTRL_STATUS_READY {
+	}
+}
+
+var (
+	errFlashADDRE   = errors.New("errFlashADDRE")
+	errFlashPROGE   = errors.New("errFlashPROGE")
+	errFlashLOCKE   = errors.New("errFlashLOCKE")
+	errFlashECCSE   = errors.New("errFlashECCSE")
+	errFlashNVME    = errors.New("errFlashNVME")
+	errFlashSEESOVF = errors.New("errFlashSEESOVF")
+)
+
+func checkFlashError() error {
+	switch {
+	case sam.NVMCTRL.GetINTENSET_ADDRE() != 0:
+		return errFlashADDRE
+	case sam.NVMCTRL.GetINTENSET_PROGE() != 0:
+		return errFlashPROGE
+	case sam.NVMCTRL.GetINTENSET_LOCKE() != 0:
+		return errFlashLOCKE
+	case sam.NVMCTRL.GetINTENSET_ECCSE() != 0:
+		return errFlashECCSE
+	case sam.NVMCTRL.GetINTENSET_NVME() != 0:
+		return errFlashNVME
+	case sam.NVMCTRL.GetINTENSET_SEESOVF() != 0:
+		return errFlashSEESOVF
+	}
+
+	return nil
+}

src/machine/machine_atsamd51_usb.go

@@ -142,8 +142,9 @@ func handleUSBIRQ(intr interrupt.Interrupt) {
 		setup := usb.NewSetup(udd_ep_out_cache_buffer[0][:])
 
 		// Clear the Bank 0 ready flag on Control OUT
-		setEPSTATUSCLR(0, sam.USB_DEVICE_ENDPOINT_EPSTATUSCLR_BK0RDY)
+		usbEndpointDescriptors[0].DeviceDescBank[0].ADDR.Set(uint32(uintptr(unsafe.Pointer(&udd_ep_out_cache_buffer[0]))))
 		usbEndpointDescriptors[0].DeviceDescBank[0].PCKSIZE.ClearBits(usb_DEVICE_PCKSIZE_BYTE_COUNT_Mask << usb_DEVICE_PCKSIZE_BYTE_COUNT_Pos)
+		setEPSTATUSCLR(0, sam.USB_DEVICE_ENDPOINT_EPSTATUSCLR_BK0RDY)
 
 		ok := false
 		if (setup.BmRequestType & usb.REQUEST_TYPE) == usb.REQUEST_STANDARD {
@@ -347,15 +348,6 @@ func sendUSBPacket(ep uint32, data []byte, maxsize uint16) {
 func ReceiveUSBControlPacket() ([cdcLineInfoSize]byte, error) {
 	var b [cdcLineInfoSize]byte
 
-	// address
-	usbEndpointDescriptors[0].DeviceDescBank[0].ADDR.Set(uint32(uintptr(unsafe.Pointer(&udd_ep_out_cache_buffer[0]))))
-
-	// set byte count to zero
-	usbEndpointDescriptors[0].DeviceDescBank[0].PCKSIZE.ClearBits(usb_DEVICE_PCKSIZE_BYTE_COUNT_Mask << usb_DEVICE_PCKSIZE_BYTE_COUNT_Pos)
-
-	// set ready for next data
-	setEPSTATUSCLR(0, sam.USB_DEVICE_ENDPOINT_EPSTATUSCLR_BK0RDY)
-
 	// Wait until OUT transfer is ready.
 	timeout := 300000
 	for (getEPSTATUS(0) & sam.USB_DEVICE_ENDPOINT_EPSTATUS_BK0RDY) == 0 {

src/machine/machine_esp32.go

@@ -143,13 +143,13 @@ func (p Pin) configure(config PinConfig, signal uint32) {
 // outFunc returns the FUNCx_OUT_SEL_CFG register used for configuring the
 // output function selection.
 func (p Pin) outFunc() *volatile.Register32 {
-	return (*volatile.Register32)(unsafe.Pointer((uintptr(unsafe.Pointer(&esp.GPIO.FUNC0_OUT_SEL_CFG)) + uintptr(p)*4)))
+	return (*volatile.Register32)(unsafe.Add(unsafe.Pointer(&esp.GPIO.FUNC0_OUT_SEL_CFG), uintptr(p)*4))
 }
 
 // inFunc returns the FUNCy_IN_SEL_CFG register used for configuring the input
 // function selection.
 func inFunc(signal uint32) *volatile.Register32 {
-	return (*volatile.Register32)(unsafe.Pointer((uintptr(unsafe.Pointer(&esp.GPIO.FUNC0_IN_SEL_CFG)) + uintptr(signal)*4)))
+	return (*volatile.Register32)(unsafe.Add(unsafe.Pointer(&esp.GPIO.FUNC0_IN_SEL_CFG), uintptr(signal)*4))
 }
 
 // Set the pin to high or low.

src/machine/machine_esp32c3.go

@@ -108,24 +108,24 @@ func (p Pin) Configure(config PinConfig) {
 // outFunc returns the FUNCx_OUT_SEL_CFG register used for configuring the
 // output function selection.
 func (p Pin) outFunc() *volatile.Register32 {
-	return (*volatile.Register32)(unsafe.Pointer((uintptr(unsafe.Pointer(&esp.GPIO.FUNC0_OUT_SEL_CFG)) + uintptr(p)*4)))
+	return (*volatile.Register32)(unsafe.Add(unsafe.Pointer(&esp.GPIO.FUNC0_OUT_SEL_CFG), uintptr(p)*4))
 }
 
 // inFunc returns the FUNCy_IN_SEL_CFG register used for configuring the input
 // function selection.
 func inFunc(signal uint32) *volatile.Register32 {
-	return (*volatile.Register32)(unsafe.Pointer((uintptr(unsafe.Pointer(&esp.GPIO.FUNC0_IN_SEL_CFG)) + uintptr(signal)*4)))
+	return (*volatile.Register32)(unsafe.Add(unsafe.Pointer(&esp.GPIO.FUNC0_IN_SEL_CFG), uintptr(signal)*4))
 }
 
 // mux returns the I/O mux configuration register corresponding to the given
 // GPIO pin.
 func (p Pin) mux() *volatile.Register32 {
-	return (*volatile.Register32)(unsafe.Pointer((uintptr(unsafe.Pointer(&esp.IO_MUX.GPIO0)) + uintptr(p)*4)))
+	return (*volatile.Register32)(unsafe.Add(unsafe.Pointer(&esp.IO_MUX.GPIO0), uintptr(p)*4))
 }
 
 // pin returns the PIN register corresponding to the given GPIO pin.
 func (p Pin) pin() *volatile.Register32 {
-	return (*volatile.Register32)(unsafe.Pointer((uintptr(unsafe.Pointer(&esp.GPIO.PIN0)) + uintptr(p)*4)))
+	return (*volatile.Register32)(unsafe.Add(unsafe.Pointer(&esp.GPIO.PIN0), uintptr(p)*4))
 }
 
 // Set the pin to high or low.

src/machine/machine_gameboyadvance.go

@@ -3,8 +3,9 @@
 package machine
 
 import (
+	"device/gba"
+
 	"image/color"
-	"runtime/interrupt"
 	"runtime/volatile"
 	"unsafe"
 )
@@ -16,40 +17,37 @@ const deviceName = "GBA"
 // Interrupt numbers as used on the GameBoy Advance. Register them with
 // runtime/interrupt.New.
 const (
-	IRQ_VBLANK  = interrupt.IRQ_VBLANK
-	IRQ_HBLANK  = interrupt.IRQ_HBLANK
-	IRQ_VCOUNT  = interrupt.IRQ_VCOUNT
-	IRQ_TIMER0  = interrupt.IRQ_TIMER0
-	IRQ_TIMER1  = interrupt.IRQ_TIMER1
-	IRQ_TIMER2  = interrupt.IRQ_TIMER2
-	IRQ_TIMER3  = interrupt.IRQ_TIMER3
-	IRQ_COM     = interrupt.IRQ_COM
-	IRQ_DMA0    = interrupt.IRQ_DMA0
-	IRQ_DMA1    = interrupt.IRQ_DMA1
-	IRQ_DMA2    = interrupt.IRQ_DMA2
-	IRQ_DMA3    = interrupt.IRQ_DMA3
-	IRQ_KEYPAD  = interrupt.IRQ_KEYPAD
-	IRQ_GAMEPAK = interrupt.IRQ_GAMEPAK
+	IRQ_VBLANK  = gba.IRQ_VBLANK
+	IRQ_HBLANK  = gba.IRQ_HBLANK
+	IRQ_VCOUNT  = gba.IRQ_VCOUNT
+	IRQ_TIMER0  = gba.IRQ_TIMER0
+	IRQ_TIMER1  = gba.IRQ_TIMER1
+	IRQ_TIMER2  = gba.IRQ_TIMER2
+	IRQ_TIMER3  = gba.IRQ_TIMER3
+	IRQ_COM     = gba.IRQ_COM
+	IRQ_DMA0    = gba.IRQ_DMA0
+	IRQ_DMA1    = gba.IRQ_DMA1
+	IRQ_DMA2    = gba.IRQ_DMA2
+	IRQ_DMA3    = gba.IRQ_DMA3
+	IRQ_KEYPAD  = gba.IRQ_KEYPAD
+	IRQ_GAMEPAK = gba.IRQ_GAMEPAK
 )
 
-// Make it easier to directly write to I/O RAM.
-var ioram = (*[0x400]volatile.Register8)(unsafe.Pointer(uintptr(0x04000000)))
-
 // Set has not been implemented.
 func (p Pin) Set(value bool) {
 	// do nothing
 }
 
-var Display = FramebufDisplay{(*[160][240]volatile.Register16)(unsafe.Pointer(uintptr(0x06000000)))}
+var Display = FramebufDisplay{(*[160][240]volatile.Register16)(unsafe.Pointer(uintptr(gba.MEM_VRAM)))}
 
 type FramebufDisplay struct {
 	port *[160][240]volatile.Register16
 }
 
 func (d FramebufDisplay) Configure() {
-	// Write into the I/O registers, setting video display parameters.
-	ioram[0].Set(0x03) // Use video mode 3 (in BG2, a 16bpp bitmap in VRAM)
-	ioram[1].Set(0x04) // Enable BG2 (BG0 = 1, BG1 = 2, BG2 = 4, ...)
+	// Use video mode 3 (in BG2, a 16bpp bitmap in VRAM) and Enable BG2
+	gba.DISP.DISPCNT.Set(gba.DISPCNT_BGMODE_3<<gba.DISPCNT_BGMODE_Pos |
+		gba.DISPCNT_SCREENDISPLAY_BG2_ENABLE<<gba.DISPCNT_SCREENDISPLAY_BG2_Pos)
 }
 
 func (d FramebufDisplay) Size() (x, y int16) {

src/machine/machine_nrf.go

@@ -3,7 +3,9 @@
 package machine
 
 import (
+	"bytes"
 	"device/nrf"
+	"encoding/binary"
 	"runtime/interrupt"
 	"unsafe"
 )
@@ -382,3 +384,109 @@ func ReadTemperature() int32 {
 	nrf.TEMP.EVENTS_DATARDY.Set(0)
 	return temp
 }
+
+const memoryStart = 0x0
+
+// compile-time check for ensuring we fulfill BlockDevice interface
+var _ BlockDevice = flashBlockDevice{}
+
+var Flash flashBlockDevice
+
+type flashBlockDevice struct {
+}
+
+// ReadAt reads the given number of bytes from the block device.
+func (f flashBlockDevice) ReadAt(p []byte, off int64) (n int, err error) {
+	if FlashDataStart()+uintptr(off)+uintptr(len(p)) > FlashDataEnd() {
+		return 0, errFlashCannotReadPastEOF
+	}
+
+	data := unsafe.Slice((*byte)(unsafe.Pointer(FlashDataStart()+uintptr(off))), len(p))
+	copy(p, data)
+
+	return len(p), nil
+}
+
+// WriteAt writes the given number of bytes to the block device.
+// Only double-word (64 bits) length data can be programmed. See rm0461 page 78.
+// If the length of p is not long enough it will be padded with 0xFF bytes.
+// This method assumes that the destination is already erased.
+func (f flashBlockDevice) WriteAt(p []byte, off int64) (n int, err error) {
+	if FlashDataStart()+uintptr(off)+uintptr(len(p)) > FlashDataEnd() {
+		return 0, errFlashCannotWritePastEOF
+	}
+
+	address := FlashDataStart() + uintptr(off)
+	padded := f.pad(p)
+
+	waitWhileFlashBusy()
+
+	nrf.NVMC.SetCONFIG_WEN(nrf.NVMC_CONFIG_WEN_Wen)
+	defer nrf.NVMC.SetCONFIG_WEN(nrf.NVMC_CONFIG_WEN_Ren)
+
+	for j := 0; j < len(padded); j += int(f.WriteBlockSize()) {
+		// write word
+		*(*uint32)(unsafe.Pointer(address)) = binary.LittleEndian.Uint32(padded[j : j+int(f.WriteBlockSize())])
+		address += uintptr(f.WriteBlockSize())
+		waitWhileFlashBusy()
+	}
+
+	return len(padded), nil
+}
+
+// Size returns the number of bytes in this block device.
+func (f flashBlockDevice) Size() int64 {
+	return int64(FlashDataEnd() - FlashDataStart())
+}
+
+const writeBlockSize = 4
+
+// WriteBlockSize returns the block size in which data can be written to
+// memory. It can be used by a client to optimize writes, non-aligned writes
+// should always work correctly.
+func (f flashBlockDevice) WriteBlockSize() int64 {
+	return writeBlockSize
+}
+
+// EraseBlockSize returns the smallest erasable area on this particular chip
+// in bytes. This is used for the block size in EraseBlocks.
+// It must be a power of two, and may be as small as 1. A typical size is 4096.
+func (f flashBlockDevice) EraseBlockSize() int64 {
+	return eraseBlockSize()
+}
+
+// EraseBlocks erases the given number of blocks. An implementation may
+// transparently coalesce ranges of blocks into larger bundles if the chip
+// supports this. The start and len parameters are in block numbers, use
+// EraseBlockSize to map addresses to blocks.
+func (f flashBlockDevice) EraseBlocks(start, len int64) error {
+	address := FlashDataStart() + uintptr(start*f.EraseBlockSize())
+	waitWhileFlashBusy()
+
+	nrf.NVMC.SetCONFIG_WEN(nrf.NVMC_CONFIG_WEN_Een)
+	defer nrf.NVMC.SetCONFIG_WEN(nrf.NVMC_CONFIG_WEN_Ren)
+
+	for i := start; i < start+len; i++ {
+		nrf.NVMC.ERASEPAGE.Set(uint32(address))
+		waitWhileFlashBusy()
+		address += uintptr(f.EraseBlockSize())
+	}
+
+	return nil
+}
+
+// pad data if needed so it is long enough for correct byte alignment on writes.
+func (f flashBlockDevice) pad(p []byte) []byte {
+	paddingNeeded := f.WriteBlockSize() - (int64(len(p)) % f.WriteBlockSize())
+	if paddingNeeded == 0 {
+		return p
+	}
+
+	padding := bytes.Repeat([]byte{0xff}, int(paddingNeeded))
+	return append(p, padding...)
+}
+
+func waitWhileFlashBusy() {
+	for nrf.NVMC.GetREADY() != nrf.NVMC_READY_READY_Ready {
+	}
+}

src/machine/machine_nrf51.go

@@ -6,6 +6,12 @@ import (
 	"device/nrf"
 )
 
+const eraseBlockSizeValue = 1024
+
+func eraseBlockSize() int64 {
+	return eraseBlockSizeValue
+}
+
 // Get peripheral and pin number for this GPIO pin.
 func (p Pin) getPortPin() (*nrf.GPIO_Type, uint32) {
 	return nrf.GPIO, uint32(p)

src/machine/machine_nrf52.go

@@ -63,3 +63,9 @@ var (
 	PWM1 = &PWM{PWM: nrf.PWM1}
 	PWM2 = &PWM{PWM: nrf.PWM2}
 )
+
+const eraseBlockSizeValue = 4096
+
+func eraseBlockSize() int64 {
+	return eraseBlockSizeValue
+}

src/machine/machine_nrf52833.go

@@ -84,3 +84,9 @@ var (
 	PWM2 = &PWM{PWM: nrf.PWM2}
 	PWM3 = &PWM{PWM: nrf.PWM3}
 )
+
+const eraseBlockSizeValue = 4096
+
+func eraseBlockSize() int64 {
+	return eraseBlockSizeValue
+}

src/machine/machine_nrf52840.go

@@ -102,3 +102,9 @@ func (pdm *PDM) Read(buf []int16) (uint32, error) {
 
 	return uint32(len(buf)), nil
 }
+
+const eraseBlockSizeValue = 4096
+
+func eraseBlockSize() int64 {
+	return eraseBlockSizeValue
+}

src/machine/machine_nrf528xx.go

@@ -25,7 +25,7 @@ func (a ADC) Configure(ADCConfig) {
 // Get returns the current value of a ADC pin in the range 0..0xffff.
 func (a ADC) Get() uint16 {
 	var pwmPin uint32
-	var value int16
+	var rawValue volatile.Register16
 
 	switch a.Pin {
 	case 2:
@@ -78,7 +78,7 @@ func (a ADC) Get() uint16 {
 	nrf.SAADC.CH[0].PSELP.Set(pwmPin)
 
 	// Destination for sample result.
-	nrf.SAADC.RESULT.PTR.Set(uint32(uintptr(unsafe.Pointer(&value))))
+	nrf.SAADC.RESULT.PTR.Set(uint32(uintptr(unsafe.Pointer(&rawValue))))
 	nrf.SAADC.RESULT.MAXCNT.Set(1) // One sample
 
 	// Start tasks.
@@ -104,6 +104,7 @@ func (a ADC) Get() uint16 {
 	// Disable the ADC.
 	nrf.SAADC.ENABLE.Set(nrf.SAADC_ENABLE_ENABLE_Disabled << nrf.SAADC_ENABLE_ENABLE_Pos)
 
+	value := int16(rawValue.Get())
 	if value < 0 {
 		value = 0
 	}

src/machine/machine_rp2040_enter_bootloader.go

@@ -1,52 +0,0 @@
-//go:build rp2040
-
-package machine
-
-/*
-// https://github.com/raspberrypi/pico-sdk
-// src/rp2_common/pico_bootrom/include/pico/bootrom.h
-
-#define ROM_FUNC_POPCOUNT32             ROM_TABLE_CODE('P', '3')
-#define ROM_FUNC_REVERSE32              ROM_TABLE_CODE('R', '3')
-#define ROM_FUNC_CLZ32                  ROM_TABLE_CODE('L', '3')
-#define ROM_FUNC_CTZ32                  ROM_TABLE_CODE('T', '3')
-#define ROM_FUNC_MEMSET                 ROM_TABLE_CODE('M', 'S')
-#define ROM_FUNC_MEMSET4                ROM_TABLE_CODE('S', '4')
-#define ROM_FUNC_MEMCPY                 ROM_TABLE_CODE('M', 'C')
-#define ROM_FUNC_MEMCPY44               ROM_TABLE_CODE('C', '4')
-#define ROM_FUNC_RESET_USB_BOOT         ROM_TABLE_CODE('U', 'B')
-#define ROM_FUNC_CONNECT_INTERNAL_FLASH ROM_TABLE_CODE('I', 'F')
-#define ROM_FUNC_FLASH_EXIT_XIP         ROM_TABLE_CODE('E', 'X')
-#define ROM_FUNC_FLASH_RANGE_ERASE      ROM_TABLE_CODE('R', 'E')
-#define ROM_FUNC_FLASH_RANGE_PROGRAM    ROM_TABLE_CODE('R', 'P')
-#define ROM_FUNC_FLASH_FLUSH_CACHE      ROM_TABLE_CODE('F', 'C')
-#define ROM_FUNC_FLASH_ENTER_CMD_XIP    ROM_TABLE_CODE('C', 'X')
-
-#define ROM_TABLE_CODE(c1, c2) ((c1) | ((c2) << 8))
-
-typedef unsigned short uint16_t;
-typedef unsigned long uint32_t;
-typedef unsigned long uintptr_t;
-
-typedef void *(*rom_table_lookup_fn)(uint16_t *table, uint32_t code);
-typedef void __attribute__((noreturn)) (*rom_reset_usb_boot_fn)(uint32_t, uint32_t);
-#define rom_hword_as_ptr(rom_address) (void *)(uintptr_t)(*(uint16_t *)(uintptr_t)(rom_address))
-
-void *rom_func_lookup(uint32_t code) {
-  rom_table_lookup_fn rom_table_lookup = (rom_table_lookup_fn) rom_hword_as_ptr(0x18);
-  uint16_t *func_table = (uint16_t *) rom_hword_as_ptr(0x14);
-  return rom_table_lookup(func_table, code);
-}
-
-void reset_usb_boot(uint32_t usb_activity_gpio_pin_mask, uint32_t disable_interface_mask) {
-    rom_reset_usb_boot_fn func = (rom_reset_usb_boot_fn) rom_func_lookup(ROM_FUNC_RESET_USB_BOOT);
-    func(usb_activity_gpio_pin_mask, disable_interface_mask);
-}
-*/
-import "C"
-
-// EnterBootloader should perform a system reset in preparation
-// to switch to the bootloader to flash new firmware.
-func EnterBootloader() {
-	C.reset_usb_boot(0, 0)
-}

src/machine/machine_rp2040_gpio.go

@@ -9,7 +9,7 @@ import (
 	"unsafe"
 )
 
-type io struct {
+type ioType struct {
 	status volatile.Register32
 	ctrl   volatile.Register32
 }
@@ -21,7 +21,7 @@ type irqCtrl struct {
 }
 
 type ioBank0Type struct {
-	io                 [30]io
+	io                 [30]ioType
 	intR               [4]volatile.Register32
 	proc0IRQctrl       irqCtrl
 	proc1IRQctrl       irqCtrl

src/machine/machine_rp2040_i2c.go

@@ -57,6 +57,8 @@ var (
 	ErrInvalidTgtAddr     = errors.New("invalid target i2c address not in 0..0x80 or is reserved")
 	ErrI2CGeneric         = errors.New("i2c error")
 	ErrRP2040I2CDisable   = errors.New("i2c rp2040 peripheral timeout in disable")
+	errInvalidI2CSDA      = errors.New("invalid I2C SDA pin")
+	errInvalidI2CSCL      = errors.New("invalid I2C SCL pin")
 )
 
 // Tx performs a write and then a read transfer placing the result in
@@ -90,7 +92,7 @@ func (i2c *I2C) Tx(addr uint16, w, r []byte) error {
 //	SCL: 3, 7, 11, 15, 19, 27
 func (i2c *I2C) Configure(config I2CConfig) error {
 	const defaultBaud uint32 = 100_000 // 100kHz standard mode
-	if config.SCL == 0 {
+	if config.SCL == 0 && config.SDA == 0 {
 		// If config pins are zero valued or clock pin is invalid then we set default values.
 		switch i2c.Bus {
 		case rp.I2C0:
@@ -101,6 +103,23 @@ func (i2c *I2C) Configure(config I2CConfig) error {
 			config.SDA = I2C1_SDA_PIN
 		}
 	}
+	var okSCL, okSDA bool
+	switch i2c.Bus {
+	case rp.I2C0:
+		okSCL = (config.SCL+3)%4 == 0
+		okSDA = (config.SDA+4)%4 == 0
+	case rp.I2C1:
+		okSCL = (config.SCL+1)%4 == 0
+		okSDA = (config.SDA+2)%4 == 0
+	}
+
+	switch {
+	case !okSCL:
+		return errInvalidI2CSCL
+	case !okSDA:
+		return errInvalidI2CSDA
+	}
+
 	if config.Frequency == 0 {
 		config.Frequency = defaultBaud
 	}

src/machine/machine_rp2040_pwm.go

@@ -50,7 +50,7 @@ type pwmGroup struct {
 //
 // 0x14 is the size of a pwmGroup.
 func getPWMGroup(index uintptr) *pwmGroup {
-	return (*pwmGroup)(unsafe.Pointer(uintptr(unsafe.Pointer(rp.PWM)) + 0x14*index))
+	return (*pwmGroup)(unsafe.Add(unsafe.Pointer(rp.PWM), 0x14*index))
 }
 
 // Hardware Pulse Width Modulation (PWM) API

src/machine/machine_rp2040_rom.go

@@ -0,0 +1,256 @@
+//go:build rp2040
+
+package machine
+
+import (
+	"bytes"
+	"runtime/interrupt"
+	"unsafe"
+)
+
+/*
+// https://github.com/raspberrypi/pico-sdk
+// src/rp2_common/pico_bootrom/include/pico/bootrom.h
+
+#define ROM_FUNC_POPCOUNT32             ROM_TABLE_CODE('P', '3')
+#define ROM_FUNC_REVERSE32              ROM_TABLE_CODE('R', '3')
+#define ROM_FUNC_CLZ32                  ROM_TABLE_CODE('L', '3')
+#define ROM_FUNC_CTZ32                  ROM_TABLE_CODE('T', '3')
+#define ROM_FUNC_MEMSET                 ROM_TABLE_CODE('M', 'S')
+#define ROM_FUNC_MEMSET4                ROM_TABLE_CODE('S', '4')
+#define ROM_FUNC_MEMCPY                 ROM_TABLE_CODE('M', 'C')
+#define ROM_FUNC_MEMCPY44               ROM_TABLE_CODE('C', '4')
+#define ROM_FUNC_RESET_USB_BOOT         ROM_TABLE_CODE('U', 'B')
+#define ROM_FUNC_CONNECT_INTERNAL_FLASH ROM_TABLE_CODE('I', 'F')
+#define ROM_FUNC_FLASH_EXIT_XIP         ROM_TABLE_CODE('E', 'X')
+#define ROM_FUNC_FLASH_RANGE_ERASE      ROM_TABLE_CODE('R', 'E')
+#define ROM_FUNC_FLASH_RANGE_PROGRAM    ROM_TABLE_CODE('R', 'P')
+#define ROM_FUNC_FLASH_FLUSH_CACHE      ROM_TABLE_CODE('F', 'C')
+#define ROM_FUNC_FLASH_ENTER_CMD_XIP    ROM_TABLE_CODE('C', 'X')
+
+#define ROM_TABLE_CODE(c1, c2) ((c1) | ((c2) << 8))
+
+typedef unsigned char uint8_t;
+typedef unsigned short uint16_t;
+typedef unsigned long uint32_t;
+typedef unsigned long size_t;
+typedef unsigned long uintptr_t;
+
+#define false 0
+#define true 1
+typedef int bool;
+
+#define ram_func __attribute__((section(".ramfuncs"),noinline))
+
+typedef void *(*rom_table_lookup_fn)(uint16_t *table, uint32_t code);
+typedef void __attribute__((noreturn)) (*rom_reset_usb_boot_fn)(uint32_t, uint32_t);
+typedef void (*flash_init_boot2_copyout_fn)(void);
+typedef void (*flash_enable_xip_via_boot2_fn)(void);
+typedef void (*flash_exit_xip_fn)(void);
+typedef void (*flash_flush_cache_fn)(void);
+typedef void (*flash_connect_internal_fn)(void);
+typedef void (*flash_range_erase_fn)(uint32_t, size_t, uint32_t, uint16_t);
+typedef void (*flash_range_program_fn)(uint32_t, const uint8_t*, size_t);
+
+static inline __attribute__((always_inline)) void __compiler_memory_barrier(void) {
+    __asm__ volatile ("" : : : "memory");
+}
+
+#define rom_hword_as_ptr(rom_address) (void *)(uintptr_t)(*(uint16_t *)(uintptr_t)(rom_address))
+
+void *rom_func_lookup(uint32_t code) {
+	rom_table_lookup_fn rom_table_lookup = (rom_table_lookup_fn) rom_hword_as_ptr(0x18);
+	uint16_t *func_table = (uint16_t *) rom_hword_as_ptr(0x14);
+	return rom_table_lookup(func_table, code);
+}
+
+void reset_usb_boot(uint32_t usb_activity_gpio_pin_mask, uint32_t disable_interface_mask) {
+	rom_reset_usb_boot_fn func = (rom_reset_usb_boot_fn) rom_func_lookup(ROM_FUNC_RESET_USB_BOOT);
+	func(usb_activity_gpio_pin_mask, disable_interface_mask);
+}
+
+#define FLASH_BLOCK_ERASE_CMD 0xd8
+
+#define FLASH_PAGE_SIZE (1u << 8)
+#define FLASH_SECTOR_SIZE (1u << 12)
+#define FLASH_BLOCK_SIZE (1u << 16)
+
+#define BOOT2_SIZE_WORDS 64
+#define XIP_BASE 0x10000000
+
+static uint32_t boot2_copyout[BOOT2_SIZE_WORDS];
+static bool boot2_copyout_valid = false;
+
+static ram_func void flash_init_boot2_copyout() {
+	if (boot2_copyout_valid)
+			return;
+	for (int i = 0; i < BOOT2_SIZE_WORDS; ++i)
+			boot2_copyout[i] = ((uint32_t *)XIP_BASE)[i];
+	__compiler_memory_barrier();
+	boot2_copyout_valid = true;
+}
+
+static ram_func void flash_enable_xip_via_boot2() {
+	((void (*)(void))boot2_copyout+1)();
+}
+
+// See https://github.com/raspberrypi/pico-sdk/blob/master/src/rp2_common/hardware_flash/flash.c#L86
+void ram_func flash_range_write(uint32_t offset, const uint8_t *data, size_t count)
+{
+	flash_range_program_fn flash_range_program_func = (flash_range_program_fn) rom_func_lookup(ROM_FUNC_FLASH_RANGE_PROGRAM);
+	flash_connect_internal_fn flash_connect_internal_func = (flash_connect_internal_fn) rom_func_lookup(ROM_FUNC_CONNECT_INTERNAL_FLASH);
+	flash_exit_xip_fn flash_exit_xip_func = (flash_exit_xip_fn) rom_func_lookup(ROM_FUNC_FLASH_EXIT_XIP);
+	flash_flush_cache_fn flash_flush_cache_func = (flash_flush_cache_fn) rom_func_lookup(ROM_FUNC_FLASH_FLUSH_CACHE);
+
+	flash_init_boot2_copyout();
+
+	__compiler_memory_barrier();
+
+	flash_connect_internal_func();
+	flash_exit_xip_func();
+
+	flash_range_program_func(offset, data, count);
+	flash_flush_cache_func();
+	flash_enable_xip_via_boot2();
+}
+
+void ram_func flash_erase_blocks(uint32_t offset, size_t count)
+{
+	flash_range_erase_fn flash_range_erase_func = (flash_range_erase_fn) rom_func_lookup(ROM_FUNC_FLASH_RANGE_ERASE);
+	flash_connect_internal_fn flash_connect_internal_func = (flash_connect_internal_fn) rom_func_lookup(ROM_FUNC_CONNECT_INTERNAL_FLASH);
+	flash_exit_xip_fn flash_exit_xip_func = (flash_exit_xip_fn) rom_func_lookup(ROM_FUNC_FLASH_EXIT_XIP);
+	flash_flush_cache_fn flash_flush_cache_func = (flash_flush_cache_fn) rom_func_lookup(ROM_FUNC_FLASH_FLUSH_CACHE);
+
+	flash_init_boot2_copyout();
+
+	__compiler_memory_barrier();
+
+	flash_connect_internal_func();
+	flash_exit_xip_func();
+
+	flash_range_erase_func(offset, count, FLASH_BLOCK_SIZE, FLASH_BLOCK_ERASE_CMD);
+	flash_flush_cache_func();
+	flash_enable_xip_via_boot2();
+}
+
+*/
+import "C"
+
+// EnterBootloader should perform a system reset in preparation
+// to switch to the bootloader to flash new firmware.
+func EnterBootloader() {
+	C.reset_usb_boot(0, 0)
+}
+
+// Flash related code
+const memoryStart = C.XIP_BASE // memory start for purpose of erase
+
+// compile-time check for ensuring we fulfill BlockDevice interface
+var _ BlockDevice = flashBlockDevice{}
+
+var Flash flashBlockDevice
+
+type flashBlockDevice struct {
+}
+
+// ReadAt reads the given number of bytes from the block device.
+func (f flashBlockDevice) ReadAt(p []byte, off int64) (n int, err error) {
+	if readAddress(off) > FlashDataEnd() {
+		return 0, errFlashCannotReadPastEOF
+	}
+
+	data := unsafe.Slice((*byte)(unsafe.Pointer(readAddress(off))), len(p))
+	copy(p, data)
+
+	return len(p), nil
+}
+
+// WriteAt writes the given number of bytes to the block device.
+// Only word (32 bits) length data can be programmed.
+// If the length of p is not long enough it will be padded with 0xFF bytes.
+// This method assumes that the destination is already erased.
+func (f flashBlockDevice) WriteAt(p []byte, off int64) (n int, err error) {
+	if writeAddress(off)+uintptr(C.XIP_BASE) > FlashDataEnd() {
+		return 0, errFlashCannotWritePastEOF
+	}
+
+	state := interrupt.Disable()
+	defer interrupt.Restore(state)
+
+	// rp2040 writes to offset, not actual address
+	// e.g. real address 0x10003000 is written to at
+	// 0x00003000
+	address := writeAddress(off)
+	padded := f.pad(p)
+
+	C.flash_range_write(C.uint32_t(address),
+		(*C.uint8_t)(unsafe.Pointer(&padded[0])),
+		C.ulong(len(padded)))
+
+	return len(padded), nil
+}
+
+// Size returns the number of bytes in this block device.
+func (f flashBlockDevice) Size() int64 {
+	return int64(FlashDataEnd() - FlashDataStart())
+}
+
+const writeBlockSize = 4
+
+// WriteBlockSize returns the block size in which data can be written to
+// memory. It can be used by a client to optimize writes, non-aligned writes
+// should always work correctly.
+func (f flashBlockDevice) WriteBlockSize() int64 {
+	return writeBlockSize
+}
+
+const eraseBlockSizeValue = 1 << 12
+
+func eraseBlockSize() int64 {
+	return eraseBlockSizeValue
+}
+
+// EraseBlockSize returns the smallest erasable area on this particular chip
+// in bytes. This is used for the block size in EraseBlocks.
+func (f flashBlockDevice) EraseBlockSize() int64 {
+	return eraseBlockSize()
+}
+
+// EraseBlocks erases the given number of blocks. An implementation may
+// transparently coalesce ranges of blocks into larger bundles if the chip
+// supports this. The start and len parameters are in block numbers, use
+// EraseBlockSize to map addresses to blocks.
+func (f flashBlockDevice) EraseBlocks(start, length int64) error {
+	address := writeAddress(start * f.EraseBlockSize())
+	if address+uintptr(C.XIP_BASE) > FlashDataEnd() {
+		return errFlashCannotErasePastEOF
+	}
+
+	state := interrupt.Disable()
+	defer interrupt.Restore(state)
+
+	C.flash_erase_blocks(C.uint32_t(address), C.ulong(length))
+
+	return nil
+}
+
+// pad data if needed so it is long enough for correct byte alignment on writes.
+func (f flashBlockDevice) pad(p []byte) []byte {
+	paddingNeeded := f.WriteBlockSize() - (int64(len(p)) % f.WriteBlockSize())
+	if paddingNeeded == 0 {
+		return p
+	}
+
+	padding := bytes.Repeat([]byte{0xff}, int(paddingNeeded))
+	return append(p, padding...)
+}
+
+// return the correct address to be used for write
+func writeAddress(off int64) uintptr {
+	return readAddress(off) - uintptr(C.XIP_BASE)
+}
+
+// return the correct address to be used for reads
+func readAddress(off int64) uintptr {
+	return FlashDataStart() + uintptr(off)
+}

src/machine/machine_rp2040_rtc.go

@@ -0,0 +1,240 @@
+//go:build rp2040
+
+// Implementation based on code located here:
+// https://github.com/raspberrypi/pico-sdk/blob/master/src/rp2_common/hardware_rtc/rtc.c
+
+package machine
+
+import (
+	"device/rp"
+	"errors"
+	"runtime/interrupt"
+	"unsafe"
+)
+
+type rtcType rp.RTC_Type
+
+type rtcTime struct {
+	Year  int16
+	Month int8
+	Day   int8
+	Dotw  int8
+	Hour  int8
+	Min   int8
+	Sec   int8
+}
+
+var RTC = (*rtcType)(unsafe.Pointer(rp.RTC))
+
+const (
+	second = 1
+	minute = 60 * second
+	hour   = 60 * minute
+	day    = 24 * hour
+)
+
+var (
+	rtcAlarmRepeats bool
+	rtcCallback     func()
+	rtcEpoch        = rtcTime{
+		Year: 1970, Month: 1, Day: 1, Dotw: 4, Hour: 0, Min: 0, Sec: 0,
+	}
+)
+
+var (
+	ErrRtcDelayTooSmall = errors.New("RTC interrupt deplay is too small, shall be at least 1 second")
+	ErrRtcDelayTooLarge = errors.New("RTC interrupt deplay is too large, shall be no more than 1 day")
+)
+
+// SetInterrupt configures delayed and optionally recurring interrupt by real time clock.
+//
+// Delay is specified in whole seconds, allowed range depends on platform.
+// Zero delay disables previously configured interrupt, if any.
+//
+// RP2040 implementation allows delay to be up to 1 day, otherwise a respective error is emitted.
+func (rtc *rtcType) SetInterrupt(delay uint32, repeat bool, callback func()) error {
+
+	// Verify delay range
+	if delay > day {
+		return ErrRtcDelayTooLarge
+	}
+
+	// De-configure delayed interrupt if delay is zero
+	if delay == 0 {
+		rtc.disableInterruptMatch()
+		return nil
+	}
+
+	// Configure delayed interrupt
+	rtc.setDivider()
+
+	rtcAlarmRepeats = repeat
+	rtcCallback = callback
+
+	err := rtc.setTime(rtcEpoch)
+	if err != nil {
+		return err
+	}
+	rtc.setAlarm(toAlarmTime(delay), callback)
+
+	return nil
+}
+
+func toAlarmTime(delay uint32) rtcTime {
+	result := rtcEpoch
+	remainder := delay + 1 // needed "+1", otherwise alarm fires one second too early
+	if remainder >= hour {
+		result.Hour = int8(remainder / hour)
+		remainder %= hour
+	}
+	if remainder >= minute {
+		result.Min = int8(remainder / minute)
+		remainder %= minute
+	}
+	result.Sec = int8(remainder)
+	return result
+}
+
+func (rtc *rtcType) setDivider() {
+	// Get clk_rtc freq and make sure it is running
+	rtcFreq := configuredFreq[clkRTC]
+	if rtcFreq == 0 {
+		panic("can not set RTC divider, clock is not running")
+	}
+
+	// Take rtc out of reset now that we know clk_rtc is running
+	resetBlock(rp.RESETS_RESET_RTC)
+	unresetBlockWait(rp.RESETS_RESET_RTC)
+
+	// Set up the 1 second divider.
+	// If rtc_freq is 400 then clkdiv_m1 should be 399
+	rtcFreq -= 1
+
+	// Check the freq is not too big to divide
+	if rtcFreq > rp.RTC_CLKDIV_M1_CLKDIV_M1_Msk {
+		panic("can not set RTC divider, clock frequency is too big to divide")
+	}
+
+	// Write divide value
+	rtc.CLKDIV_M1.Set(rtcFreq)
+}
+
+// setTime configures RTC with supplied time, initialises and activates it.
+func (rtc *rtcType) setTime(t rtcTime) error {
+
+	// Disable RTC and wait while it is still running
+	rtc.CTRL.Set(0)
+	for rtc.isActive() {
+	}
+
+	rtc.SETUP_0.Set((uint32(t.Year) << rp.RTC_SETUP_0_YEAR_Pos) |
+		(uint32(t.Month) << rp.RTC_SETUP_0_MONTH_Pos) |
+		(uint32(t.Day) << rp.RTC_SETUP_0_DAY_Pos))
+
+	rtc.SETUP_1.Set((uint32(t.Dotw) << rp.RTC_SETUP_1_DOTW_Pos) |
+		(uint32(t.Hour) << rp.RTC_SETUP_1_HOUR_Pos) |
+		(uint32(t.Min) << rp.RTC_SETUP_1_MIN_Pos) |
+		(uint32(t.Sec) << rp.RTC_SETUP_1_SEC_Pos))
+
+	// Load setup values into RTC clock domain
+	rtc.CTRL.SetBits(rp.RTC_CTRL_LOAD)
+
+	// Enable RTC and wait for it to be running
+	rtc.CTRL.SetBits(rp.RTC_CTRL_RTC_ENABLE)
+	for !rtc.isActive() {
+	}
+
+	return nil
+}
+
+func (rtc *rtcType) isActive() bool {
+	return rtc.CTRL.HasBits(rp.RTC_CTRL_RTC_ACTIVE)
+}
+
+// setAlarm configures alarm in RTC and arms it.
+// The callback is executed in the context of an interrupt handler,
+// so regular restructions for this sort of code apply: no blocking, no memory allocation, etc.
+func (rtc *rtcType) setAlarm(t rtcTime, callback func()) {
+
+	rtc.disableInterruptMatch()
+
+	// Clear all match enable bits
+	rtc.IRQ_SETUP_0.ClearBits(rp.RTC_IRQ_SETUP_0_YEAR_ENA | rp.RTC_IRQ_SETUP_0_MONTH_ENA | rp.RTC_IRQ_SETUP_0_DAY_ENA)
+	rtc.IRQ_SETUP_1.ClearBits(rp.RTC_IRQ_SETUP_1_DOTW_ENA | rp.RTC_IRQ_SETUP_1_HOUR_ENA | rp.RTC_IRQ_SETUP_1_MIN_ENA | rp.RTC_IRQ_SETUP_1_SEC_ENA)
+
+	// Only add to setup if it isn't -1 and set the match enable bits for things we care about
+	if t.Year >= 0 {
+		rtc.IRQ_SETUP_0.SetBits(uint32(t.Year) << rp.RTC_SETUP_0_YEAR_Pos)
+		rtc.IRQ_SETUP_0.SetBits(rp.RTC_IRQ_SETUP_0_YEAR_ENA)
+	}
+
+	if t.Month >= 0 {
+		rtc.IRQ_SETUP_0.SetBits(uint32(t.Month) << rp.RTC_SETUP_0_MONTH_Pos)
+		rtc.IRQ_SETUP_0.SetBits(rp.RTC_IRQ_SETUP_0_MONTH_ENA)
+	}
+
+	if t.Day >= 0 {
+		rtc.IRQ_SETUP_0.SetBits(uint32(t.Day) << rp.RTC_SETUP_0_DAY_Pos)
+		rtc.IRQ_SETUP_0.SetBits(rp.RTC_IRQ_SETUP_0_DAY_ENA)
+	}
+
+	if t.Dotw >= 0 {
+		rtc.IRQ_SETUP_1.SetBits(uint32(t.Dotw) << rp.RTC_SETUP_1_DOTW_Pos)
+		rtc.IRQ_SETUP_1.SetBits(rp.RTC_IRQ_SETUP_1_DOTW_ENA)
+	}
+
+	if t.Hour >= 0 {
+		rtc.IRQ_SETUP_1.SetBits(uint32(t.Hour) << rp.RTC_SETUP_1_HOUR_Pos)
+		rtc.IRQ_SETUP_1.SetBits(rp.RTC_IRQ_SETUP_1_HOUR_ENA)
+	}
+
+	if t.Min >= 0 {
+		rtc.IRQ_SETUP_1.SetBits(uint32(t.Min) << rp.RTC_SETUP_1_MIN_Pos)
+		rtc.IRQ_SETUP_1.SetBits(rp.RTC_IRQ_SETUP_1_MIN_ENA)
+	}
+
+	if t.Sec >= 0 {
+		rtc.IRQ_SETUP_1.SetBits(uint32(t.Sec) << rp.RTC_SETUP_1_SEC_Pos)
+		rtc.IRQ_SETUP_1.SetBits(rp.RTC_IRQ_SETUP_1_SEC_ENA)
+	}
+
+	// Enable the IRQ at the proc
+	interrupt.New(rp.IRQ_RTC_IRQ, rtcHandleInterrupt).Enable()
+
+	// Enable the IRQ at the peri
+	rtc.INTE.Set(rp.RTC_INTE_RTC)
+
+	rtc.enableInterruptMatch()
+}
+
+func (rtc *rtcType) enableInterruptMatch() {
+	// Set matching and wait for it to be enabled
+	rtc.IRQ_SETUP_0.SetBits(rp.RTC_IRQ_SETUP_0_MATCH_ENA)
+	for !rtc.IRQ_SETUP_0.HasBits(rp.RTC_IRQ_SETUP_0_MATCH_ACTIVE) {
+	}
+}
+
+func (rtc *rtcType) disableInterruptMatch() {
+	// Disable matching and wait for it to stop being active
+	rtc.IRQ_SETUP_0.ClearBits(rp.RTC_IRQ_SETUP_0_MATCH_ENA)
+	for rtc.IRQ_SETUP_0.HasBits(rp.RTC_IRQ_SETUP_0_MATCH_ACTIVE) {
+	}
+}
+
+func rtcHandleInterrupt(itr interrupt.Interrupt) {
+	// Always disable the alarm to clear the current IRQ.
+	// Even if it is a repeatable alarm, we don't want it to keep firing.
+	// If it matches on a second it can keep firing for that second.
+	RTC.disableInterruptMatch()
+
+	// Call user callback function
+	if rtcCallback != nil {
+		rtcCallback()
+	}
+
+	if rtcAlarmRepeats {
+		// If it is a repeatable alarm, reset time and re-enable the alarm.
+		RTC.setTime(rtcEpoch)
+		RTC.enableInterruptMatch()
+	}
+}

src/machine/machine_rp2040_spi.go

@@ -26,8 +26,6 @@ type SPIConfig struct {
 	LSBFirst bool
 	// Mode's two most LSB are CPOL and CPHA. i.e. Mode==2 (0b10) is CPOL=1, CPHA=0
 	Mode uint8
-	// Number of data bits per transfer. Valid values 4..16. Default and recommended is 8.
-	DataBits uint8
 	// Serial clock pin
 	SCK Pin
 	// TX or Serial Data Out (MOSI if rp2040 is master)
@@ -40,6 +38,9 @@ var (
 	ErrLSBNotSupported = errors.New("SPI LSB unsupported on PL022")
 	ErrSPITimeout      = errors.New("SPI timeout")
 	ErrSPIBaud         = errors.New("SPI baud too low or above 66.5Mhz")
+	errSPIInvalidSDI   = errors.New("invalid SPI SDI pin")
+	errSPIInvalidSDO   = errors.New("invalid SPI SDO pin")
+	errSPIInvalidSCK   = errors.New("invalid SPI SCK pin")
 )
 
 type SPI struct {
@@ -113,7 +114,7 @@ func (spi SPI) Transfer(w byte) (byte, error) {
 
 func (spi SPI) SetBaudRate(br uint32) error {
 	const freqin uint32 = 125 * MHz
-	const maxBaud uint32 = 66.5 * MHz // max output frequency is 66.5MHz on rp2040. see Note page 527.
+	const maxBaud uint32 = 62.5 * MHz // max output frequency is 62.5MHz on rp2040, see page 507
 	// Find smallest prescale value which puts output frequency in range of
 	// post-divide. Prescale is an even number from 2 to 254 inclusive.
 	var prescale, postdiv uint32
@@ -162,7 +163,7 @@ func (spi SPI) GetBaudRate() uint32 {
 // No pin configuration is needed of SCK, SDO and SDI needed after calling Configure.
 func (spi SPI) Configure(config SPIConfig) error {
 	const defaultBaud uint32 = 115200
-	if config.SCK == 0 {
+	if config.SCK == 0 && config.SDO == 0 && config.SDI == 0 {
 		// set default pins if config zero valued or invalid clock pin supplied.
 		switch spi.Bus {
 		case rp.SPI0:
@@ -175,9 +176,27 @@ func (spi SPI) Configure(config SPIConfig) error {
 			config.SDI = SPI1_SDI_PIN
 		}
 	}
-	if config.DataBits < 4 || config.DataBits > 16 {
-		config.DataBits = 8
+	var okSDI, okSDO, okSCK bool
+	switch spi.Bus {
+	case rp.SPI0:
+		okSDI = config.SDI == 0 || config.SDI == 4 || config.SDI == 16 || config.SDI == 20
+		okSDO = config.SDO == 3 || config.SDO == 7 || config.SDO == 19 || config.SDO == 23
+		okSCK = config.SCK == 2 || config.SCK == 6 || config.SCK == 18 || config.SCK == 22
+	case rp.SPI1:
+		okSDI = config.SDI == 8 || config.SDI == 12 || config.SDI == 24 || config.SDI == 28
+		okSDO = config.SDO == 11 || config.SDO == 15 || config.SDO == 27
+		okSCK = config.SCK == 10 || config.SCK == 14 || config.SCK == 26
 	}
+
+	switch {
+	case !okSDI:
+		return errSPIInvalidSDI
+	case !okSDO:
+		return errSPIInvalidSDO
+	case !okSCK:
+		return errSPIInvalidSCK
+	}
+
 	if config.Frequency == 0 {
 		config.Frequency = defaultBaud
 	}
@@ -197,7 +216,7 @@ func (spi SPI) initSPI(config SPIConfig) (err error) {
 	}
 	err = spi.SetBaudRate(config.Frequency)
 	// Set SPI Format (CPHA and CPOL) and frame format (default is Motorola)
-	spi.setFormat(config.DataBits, config.Mode, rp.XIP_SSI_CTRLR0_SPI_FRF_STD)
+	spi.setFormat(config.Mode, rp.XIP_SSI_CTRLR0_SPI_FRF_STD)
 
 	// Always enable DREQ signals -- harmless if DMA is not listening
 	spi.Bus.SSPDMACR.SetBits(rp.SPI0_SSPDMACR_TXDMAE | rp.SPI0_SSPDMACR_RXDMAE)
@@ -207,13 +226,13 @@ func (spi SPI) initSPI(config SPIConfig) (err error) {
 }
 
 //go:inline
-func (spi SPI) setFormat(databits, mode uint8, frameFormat uint32) {
+func (spi SPI) setFormat(mode uint8, frameFormat uint32) {
 	cpha := uint32(mode) & 1
 	cpol := uint32(mode>>1) & 1
 	spi.Bus.SSPCR0.ReplaceBits(
 		(cpha<<rp.SPI0_SSPCR0_SPH_Pos)|
 			(cpol<<rp.SPI0_SSPCR0_SPO_Pos)|
-			(uint32(databits-1)<<rp.SPI0_SSPCR0_DSS_Pos)| // Set databits (SPI word length). Valid inputs are 4-16.
+			(uint32(7)<<rp.SPI0_SSPCR0_DSS_Pos)| // Set databits (SPI word length) to 8 bits.
 			(frameFormat&0b11)<<rp.SPI0_SSPCR0_FRF_Pos, // Frame format bits 4:5
 		rp.SPI0_SSPCR0_SPH_Msk|rp.SPI0_SSPCR0_SPO_Msk|rp.SPI0_SSPCR0_DSS_Msk|rp.SPI0_SSPCR0_FRF_Msk, 0)
 }