Added mstats fields

.circleci/config.yml

@@ -105,6 +105,13 @@ jobs:
       - test-linux:
           llvm: "14"
     resource_class: large
+  test-llvm15-go120:
+    docker:
+      - image: golang:1.20-rc-buster
+    steps:
+      - test-linux:
+          llvm: "15"
+    resource_class: large
 
 workflows:
   test-all:
@@ -112,3 +119,4 @@ workflows:
       # This tests our lowest supported versions of Go and LLVM, to make sure at
       # least the smoke tests still pass.
       - test-llvm14-go118
+      - test-llvm15-go120

.dockerignore

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

.github/workflows/build-macos.yml

@@ -27,13 +27,13 @@ jobs:
       - name: Install Go
         uses: actions/setup-go@v3
         with:
-          go-version: '1.20'
+          go-version: '1.19'
           cache: true
-      - name: Restore LLVM source cache
-        uses: actions/cache/restore@v3
+      - name: Cache LLVM source
+        uses: actions/cache@v3
         id: cache-llvm-source
         with:
-          key: llvm-source-15-macos-v3
+          key: llvm-source-15-macos-v2
           path: |
             llvm-project/clang/lib/Headers
             llvm-project/clang/include
@@ -43,22 +43,11 @@ jobs:
       - name: Download LLVM source
         if: steps.cache-llvm-source.outputs.cache-hit != 'true'
         run: make llvm-source
-      - 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
+      - name: Cache LLVM build
+        uses: actions/cache@v3
         id: cache-llvm-build
         with:
-          key: llvm-build-15-macos-v4
+          key: llvm-build-15-macos-v2
           path: llvm-build
       - name: Build LLVM
         if: steps.cache-llvm-build.outputs.cache-hit != 'true'
@@ -72,12 +61,6 @@ 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
@@ -89,7 +72,7 @@ jobs:
         run: make wasi-libc
       - name: Test TinyGo
         shell: bash
-        run: make test GOTESTFLAGS="-short"
+        run: make test GOTESTFLAGS="-v -short"
       - name: Build TinyGo release tarball
         run: make release -j3
       - name: Test stdlib packages
@@ -120,11 +103,11 @@ jobs:
         run: |
           HOMEBREW_NO_AUTO_UPDATE=1 brew install llvm@15
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v2
       - name: Install Go
         uses: actions/setup-go@v3
         with:
-          go-version: '1.20'
+          go-version: '1.19'
           cache: true
       - name: Build TinyGo
         run: go install

.github/workflows/docker.yml

@@ -53,7 +53,6 @@ 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
@@ -70,31 +69,21 @@ 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 Github Actions
+      - name: Trigger TinyFS repo build on CircleCI
         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/tinyfs/actions/workflows/build.yml/dispatches \
-          -d '{"ref": "dev"}'
-      - name: Trigger TinyFont repo build on Github Actions
+          curl --location --request POST 'https://circleci.com/api/v2/project/github/tinygo-org/tinyfs/pipeline' \
+            --header 'Content-Type: application/json' \
+            -d '{"branch": "dev"}' \
+            -u "${{ secrets.CIRCLECI_API_TOKEN }}"
+      - name: Trigger TinyFont repo build on CircleCI
         run: |
-          curl -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
+          curl --location --request POST 'https://circleci.com/api/v2/project/github/tinygo-org/tinyfont/pipeline' \
+            --header 'Content-Type: application/json' \
+            -d '{"branch": "dev"}' \
+            -u "${{ secrets.CIRCLECI_API_TOKEN }}"
+      - name: Trigger TinyDraw repo build on CircleCI
         run: |
-          curl -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"}'
+          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 }}"

.github/workflows/linux.yml

@@ -18,7 +18,7 @@ jobs:
     # statically linked binary.
     runs-on: ubuntu-latest
     container:
-      image: golang:1.20-alpine
+      image: golang:1.19-alpine
     steps:
       - name: Install apk dependencies
         # tar: needed for actions/cache@v3
@@ -39,11 +39,11 @@ jobs:
           path: |
             ~/.cache/go-build
             ~/go/pkg/mod
-      - name: Restore LLVM source cache
-        uses: actions/cache/restore@v3
+      - name: Cache LLVM source
+        uses: actions/cache@v3
         id: cache-llvm-source
         with:
-          key: llvm-source-15-linux-alpine-v3
+          key: llvm-source-15-linux-alpine-v2
           path: |
             llvm-project/clang/lib/Headers
             llvm-project/clang/include
@@ -53,22 +53,11 @@ jobs:
       - name: Download LLVM source
         if: steps.cache-llvm-source.outputs.cache-hit != 'true'
         run: make llvm-source
-      - 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
+      - name: Cache LLVM build
+        uses: actions/cache@v3
         id: cache-llvm-build
         with:
-          key: llvm-build-15-linux-alpine-v4
+          key: llvm-build-15-linux-alpine-v2
           path: llvm-build
       - name: Build LLVM
         if: steps.cache-llvm-build.outputs.cache-hit != 'true'
@@ -82,12 +71,6 @@ 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
@@ -135,13 +118,11 @@ jobs:
       - name: Install Go
         uses: actions/setup-go@v3
         with:
-          go-version: '1.20'
+          go-version: '1.19'
           cache: true
       - name: Install wasmtime
         run: |
-          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/*
+          curl https://wasmtime.dev/install.sh -sSf | bash
           echo "$HOME/.wasmtime/bin" >> $GITHUB_PATH
       - name: Download release artifact
         uses: actions/download-artifact@v3
@@ -177,7 +158,7 @@ jobs:
       - name: Install Go
         uses: actions/setup-go@v3
         with:
-          go-version: '1.20'
+          go-version: '1.19'
           cache: true
       - name: Install Node.js
         uses: actions/setup-node@v3
@@ -185,15 +166,13 @@ jobs:
           node-version: '14'
       - name: Install wasmtime
         run: |
-          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/*
+          curl https://wasmtime.dev/install.sh -sSf | bash
           echo "$HOME/.wasmtime/bin" >> $GITHUB_PATH
-      - name: Restore LLVM source cache
-        uses: actions/cache/restore@v3
+      - name: Cache LLVM source
+        uses: actions/cache@v3
         id: cache-llvm-source
         with:
-          key: llvm-source-15-linux-asserts-v3
+          key: llvm-source-15-linux-asserts-v2
           path: |
             llvm-project/clang/lib/Headers
             llvm-project/clang/include
@@ -203,22 +182,11 @@ jobs:
       - name: Download LLVM source
         if: steps.cache-llvm-source.outputs.cache-hit != 'true'
         run: make llvm-source
-      - 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
+      - name: Cache LLVM build
+        uses: actions/cache@v3
         id: cache-llvm-build
         with:
-          key: llvm-build-15-linux-asserts-v4
+          key: llvm-build-15-linux-asserts-v2
           path: llvm-build
       - name: Build LLVM
         if: steps.cache-llvm-build.outputs.cache-hit != 'true'
@@ -230,12 +198,6 @@ 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
@@ -290,13 +252,13 @@ jobs:
       - name: Install Go
         uses: actions/setup-go@v3
         with:
-          go-version: '1.20'
+          go-version: '1.19'
           cache: true
-      - name: Restore LLVM source cache
-        uses: actions/cache/restore@v3
+      - name: Cache LLVM source
+        uses: actions/cache@v3
         id: cache-llvm-source
         with:
-          key: llvm-source-15-linux-v3
+          key: llvm-source-15-linux-v2
           path: |
             llvm-project/clang/lib/Headers
             llvm-project/clang/include
@@ -306,22 +268,11 @@ jobs:
       - name: Download LLVM source
         if: steps.cache-llvm-source.outputs.cache-hit != 'true'
         run: make llvm-source
-      - 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
+      - name: Cache LLVM build
+        uses: actions/cache@v3
         id: cache-llvm-build
         with:
-          key: llvm-build-15-linux-arm-v4
+          key: llvm-build-15-linux-arm-v2
           path: llvm-build
       - name: Build LLVM
         if: steps.cache-llvm-build.outputs.cache-hit != 'true'
@@ -335,12 +286,6 @@ 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
@@ -407,13 +352,13 @@ jobs:
       - name: Install Go
         uses: actions/setup-go@v3
         with:
-          go-version: '1.20'
+          go-version: '1.19'
           cache: true
-      - name: Restore LLVM source cache
-        uses: actions/cache/restore@v3
+      - name: Cache LLVM source
+        uses: actions/cache@v3
         id: cache-llvm-source
         with:
-          key: llvm-source-15-linux-v3
+          key: llvm-source-15-linux-v2
           path: |
             llvm-project/clang/lib/Headers
             llvm-project/clang/include
@@ -423,22 +368,11 @@ jobs:
       - name: Download LLVM source
         if: steps.cache-llvm-source.outputs.cache-hit != 'true'
         run: make llvm-source
-      - 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
+      - name: Cache LLVM build
+        uses: actions/cache@v3
         id: cache-llvm-build
         with:
-          key: llvm-build-15-linux-arm64-v4
+          key: llvm-build-15-linux-arm64-v2
           path: llvm-build
       - name: Build LLVM
         if: steps.cache-llvm-build.outputs.cache-hit != 'true'
@@ -450,12 +384,6 @@ 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/windows.yml

@@ -15,12 +15,6 @@ 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'
@@ -35,13 +29,13 @@ jobs:
       - name: Install Go
         uses: actions/setup-go@v3
         with:
-          go-version: '1.20'
+          go-version: '1.19'
           cache: true
-      - name: Restore cached LLVM source
-        uses: actions/cache/restore@v3
+      - name: Cache LLVM source
+        uses: actions/cache@v3
         id: cache-llvm-source
         with:
-          key: llvm-source-15-windows-v4
+          key: llvm-source-15-windows-v2
           path: |
             llvm-project/clang/lib/Headers
             llvm-project/clang/include
@@ -51,22 +45,11 @@ jobs:
       - name: Download LLVM source
         if: steps.cache-llvm-source.outputs.cache-hit != 'true'
         run: make llvm-source
-      - 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
+      - name: Cache LLVM build
+        uses: actions/cache@v3
         id: cache-llvm-build
         with:
-          key: llvm-build-15-windows-v5
+          key: llvm-build-15-windows-v2
           path: llvm-build
       - name: Build LLVM
         if: steps.cache-llvm-build.outputs.cache-hit != 'true'
@@ -79,12 +62,6 @@ 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
@@ -99,7 +76,7 @@ jobs:
           scoop install wasmtime
       - name: Test TinyGo
         shell: bash
-        run: make test GOTESTFLAGS="-short"
+        run: make test GOTESTFLAGS="-v -short"
       - name: Build TinyGo release tarball
         shell: bash
         run: make build/release -j4
@@ -123,12 +100,6 @@ 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'
@@ -137,11 +108,11 @@ jobs:
         run: |
           scoop install binaryen
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v2
       - name: Install Go
         uses: actions/setup-go@v3
         with:
-          go-version: '1.20'
+          go-version: '1.19'
           cache: true
       - name: Download TinyGo build
         uses: actions/download-artifact@v2
@@ -160,18 +131,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
+        uses: actions/checkout@v2
       - name: Install Go
         uses: actions/setup-go@v3
         with:
-          go-version: '1.20'
+          go-version: '1.19'
           cache: true
       - name: Download TinyGo build
         uses: actions/download-artifact@v2
@@ -189,12 +154,6 @@ 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'
@@ -203,11 +162,11 @@ jobs:
         run: |
           scoop install binaryen wasmtime
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v2
       - name: Install Go
         uses: actions/setup-go@v3
         with:
-          go-version: '1.20'
+          go-version: '1.19'
           cache: true
       - name: Download TinyGo build
         uses: actions/download-artifact@v2

CHANGELOG.md

@@ -1,100 +1,3 @@
-0.27.0
----
-
-* **general**
-  - all: update musl
-  - all: remove "acm:"` prefix for USB vid/pid pair
-  - all: add support for LLVM 15
-  - all: use DWARF version 4
-  - all: add initial (incomplete) support for Go 1.20
-  - all: add `-gc=custom` option
-  - `main`: print ldflags including ThinLTO flags with -x
-  - `main`: fix error message when a serial port can't be accessed
-  - `main`: add `-timeout` flag to allow setting how long TinyGo will try looking for a MSD volume for flashing
-  - `test`: print PASS on pass when running standalone test binaries
-  - `test`: fix printing of benchmark output
-  - `test`: print package name when compilation failed (not just when the test failed)
-* **compiler**
-  - refactor to support LLVM 15
-  - `builder`: print compiler commands while building a library
-  - `compiler`: fix stack overflow when creating recursive pointer types (fix for LLVM 15+ only)
-  - `compiler`: allow map keys and values of ≥256 bytes
-  - `cgo`: add support for `C.float` and `C.double`
-  - `cgo`: support anonymous enums included in multiple Go files
-  - `cgo`: add support for bitwise operators
-  - `interp`: add support for constant icmp instructions
-  - `transform`: fix memory corruption issues
-* **standard library**
-  - `machine/usb`: remove allocs in USB ISR
-  - `machine/usb`: add `Port()` and deprecate `New()` to have the API better match the singleton that is actually being returned
-  - `machine/usb`: change HID usage-maximum to 0xFF
-  - `machine/usb`: add USB HID joystick support
-  - `machine/usb`: change to not send before endpoint initialization
-  - `net`: implement `Pipe`
-  - `os`: add stub for `os.Chtimes`
-  - `reflect`: stub out `Type.FieldByIndex`
-  - `reflect`: add `Value.IsZero` method
-  - `reflect`: fix bug in `.Field` method when the field fits in a pointer but the parent doesn't
-  - `runtime`: switch some `panic()` calls in the gc to `runtimePanic()` for consistency
-  - `runtime`: add xorshift-based fastrand64
-  - `runtime`: fix alignment for arm64, arm, xtensa, riscv
-  - `runtime`: implement precise GC
-  - `runtime/debug`: stub `PrintStack`
-  - `sync`: implement simple pooling in `sync.Pool`
-  - `syscall`: stubbed `Setuid`, Exec and friends
-  - `syscall`: add more stubs as needed for Go 1.20 support
-  - `testing`: implement `t.Setenv`
-  - `unsafe`: add support for Go 1.20 slice/string functions
-* **targets**
-  - `all`: do not set stack size per board
-  - `all`: update picolibc to v1.7.9
-  - `atsame5x`: fix CAN extendedID handling
-  - `atsame5x`: reduce heap allocation
-  - `avr`: drop GNU toolchain dependency
-  - `avr`: fix .data initialization for binaries over 64kB
-  - `avr`: support ThinLTO
-  - `baremetal`: implements calloc
-  - `darwin`: fix `syscall.Open` on darwin/arm64
-  - `darwin`: fix error with `tinygo lldb`
-  - `esp`: use LLVM Xtensa linker instead of Espressif toolchain
-  - `esp`: use ThinLTO for Xtensa
-  - `esp32c3`: add SPI support
-  - `linux`: include musl `getpagesize` function in release
-  - `nrf51`: add ADC implementation
-  - `nrf52840`: add PDM support
-  - `riscv`: add "target-abi" metadata flag
-  - `rp2040`: remove mem allocation in GPIO ISR
-  - `rp2040`: avoid allocating clock on heap
-  - `rp2040`: add basic GPIO support for PIO
-  - `rp2040`: fix USB interrupt issue
-  - `rp2040`: fix RP2040-E5 USB errata
-  - `stm32`: always set ADC pins to pullups floating
-  - `stm32f1`, `stm32f4`: fix ADC by clearing the correct bit for rank after each read
-  - `stm32wl`: Fix incomplete RNG initialisation
-  - `stm32wlx`: change order for init so clock speeds are set before peripheral start
-  - `wasi`: makes wasmtime "run" explicit
-  - `wasm`: fix GC scanning of allocas
-  - `wasm`: allow custom malloc implementation
-  - `wasm`: remove `-wasm-abi=` flag (use `-target` instead)
-  - `wasm`: fix scanning of the stack
-  - `wasm`: fix panic when allocating 0 bytes using malloc
-  - `wasm`: always run wasm-opt even with `-scheduler=none`
-  - `wasm`: avoid miscompile with ThinLTO
-  - `wasm`: allow the emulator to expand `{tmpDir}`
-  - `wasm`: support ThinLTO
-  - `windows`: update mingw-w64 version to avoid linker warning
-  - `windows`: add ARM64 support
-* **boards**
-  - Add Waveshare RP2040 Zero
-  - Add Arduino Leonardo support
-  - Add Adafruit KB2040
-  - Add Adafruit Feather M0 Express
-  - Add Makerfabs ESP32C3SPI35 TFT Touchscreen board
-  - Add Espressif ESP32-C3-DevKit-RUST-1 board
-  - `lgt92`: fix OpenOCD configuration
-  - `xiao-rp2040`: fix D9 and D10 constants
-  - `xiao-rp2040`: add pin definitions
-
 0.26.0
 ---
 

Dockerfile

@@ -1,5 +1,5 @@
 # tinygo-llvm stage obtains the llvm source for TinyGo
-FROM golang:1.20 AS tinygo-llvm
+FROM golang:1.19 AS tinygo-llvm
 
 RUN apt-get update && \
     apt-get install -y apt-utils make cmake clang-11 ninja-build

Makefile

@@ -30,7 +30,7 @@ GO ?= go
 export GOROOT = $(shell $(GO) env GOROOT)
 
 # Flags to pass to go test.
-GOTESTFLAGS ?=
+GOTESTFLAGS ?= -v
 
 # md5sum binary
 MD5SUM = md5sum
@@ -242,7 +242,7 @@ llvm-source: $(LLVM_PROJECTDIR)/llvm
 # Configure LLVM.
 TINYGO_SOURCE_DIR=$(shell pwd)
 $(LLVM_BUILDDIR)/build.ninja:
-	mkdir -p $(LLVM_BUILDDIR) && cd $(LLVM_BUILDDIR) && cmake -G Ninja $(TINYGO_SOURCE_DIR)/$(LLVM_PROJECTDIR)/llvm "-DLLVM_TARGETS_TO_BUILD=X86;ARM;AArch64;RISCV;WebAssembly" "-DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD=AVR;Xtensa" -DCMAKE_BUILD_TYPE=Release -DLIBCLANG_BUILD_STATIC=ON -DLLVM_ENABLE_TERMINFO=OFF -DLLVM_ENABLE_ZLIB=OFF -DLLVM_ENABLE_ZSTD=OFF -DLLVM_ENABLE_LIBEDIT=OFF -DLLVM_ENABLE_Z3_SOLVER=OFF -DLLVM_ENABLE_OCAMLDOC=OFF -DLLVM_ENABLE_LIBXML2=OFF -DLLVM_ENABLE_PROJECTS="clang;lld" -DLLVM_TOOL_CLANG_TOOLS_EXTRA_BUILD=OFF -DCLANG_ENABLE_STATIC_ANALYZER=OFF -DCLANG_ENABLE_ARCMT=OFF $(LLVM_OPTION)
+	mkdir -p $(LLVM_BUILDDIR) && cd $(LLVM_BUILDDIR) && cmake -G Ninja $(TINYGO_SOURCE_DIR)/$(LLVM_PROJECTDIR)/llvm "-DLLVM_TARGETS_TO_BUILD=X86;ARM;AArch64;RISCV;WebAssembly" "-DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD=AVR;Xtensa" -DCMAKE_BUILD_TYPE=Release -DLIBCLANG_BUILD_STATIC=ON -DLLVM_ENABLE_TERMINFO=OFF -DLLVM_ENABLE_ZLIB=OFF -DLLVM_ENABLE_LIBEDIT=OFF -DLLVM_ENABLE_Z3_SOLVER=OFF -DLLVM_ENABLE_OCAMLDOC=OFF -DLLVM_ENABLE_LIBXML2=OFF -DLLVM_ENABLE_PROJECTS="clang;lld" -DLLVM_TOOL_CLANG_TOOLS_EXTRA_BUILD=OFF -DCLANG_ENABLE_STATIC_ANALYZER=OFF -DCLANG_ENABLE_ARCMT=OFF $(LLVM_OPTION)
 
 # Build LLVM.
 $(LLVM_BUILDDIR): $(LLVM_BUILDDIR)/build.ninja
@@ -296,7 +296,6 @@ TEST_PACKAGES_FAST = \
 	encoding \
 	encoding/ascii85 \
 	encoding/base32 \
-	encoding/base64 \
 	encoding/csv \
 	encoding/hex \
 	go/scanner \
@@ -332,34 +331,26 @@ 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 \
 	strconv \
 	testing/fstest \
-	text/tabwriter \
 	text/template/parse
 
 TEST_PACKAGES_DARWIN := $(TEST_PACKAGES_LINUX)
@@ -474,8 +465,6 @@ 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

builder/build.go

@@ -169,14 +169,12 @@ 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(),
 		DefaultStackSize:   config.StackSize(),
 		NeedsStackObjects:  config.NeedsStackObjects(),
 		Debug:              true,
-		LTO:                config.LTO() != "legacy",
 	}
 
 	// Load the target machine, which is the LLVM object that contains all
@@ -307,6 +305,7 @@ 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,
@@ -453,24 +452,18 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 				if err != nil {
 					return err
 				}
-				if compilerConfig.LTO {
-					buf := llvm.WriteThinLTOBitcodeToMemoryBuffer(mod)
+				if runtime.GOOS == "windows" {
+					// Work around a problem on Windows.
+					// For some reason, WriteBitcodeToFile causes TinyGo to
+					// exit with the following message:
+					//   LLVM ERROR: IO failure on output stream: Bad file descriptor
+					buf := llvm.WriteBitcodeToMemoryBuffer(mod)
 					defer buf.Dispose()
 					_, err = f.Write(buf.Bytes())
 				} else {
-					if runtime.GOOS == "windows" {
-						// Work around a problem on Windows.
-						// For some reason, WriteBitcodeToFile causes TinyGo to
-						// exit with the following message:
-						//   LLVM ERROR: IO failure on output stream: Bad file descriptor
-						buf := llvm.WriteBitcodeToMemoryBuffer(mod)
-						defer buf.Dispose()
-						_, err = f.Write(buf.Bytes())
-					} else {
-						// Otherwise, write bitcode directly to the file (probably
-						// faster).
-						err = llvm.WriteBitcodeToFile(mod, f)
-					}
+					// Otherwise, write bitcode directly to the file (probably
+					// faster).
+					err = llvm.WriteBitcodeToFile(mod, f)
 				}
 				if err != nil {
 					// WriteBitcodeToFile doesn't produce a useful error on its
@@ -518,11 +511,24 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 
 			// Create runtime.initAll function that calls the runtime
 			// initializer of each package.
-			initAllModule := createInitAll(ctx, config, compilerConfig, lprogram.Sorted())
-			err := llvm.LinkModules(mod, initAllModule)
-			if err != nil {
-				return fmt.Errorf("failed to link module: %w", err)
+			llvmInitFn := mod.NamedFunction("runtime.initAll")
+			llvmInitFn.SetLinkage(llvm.InternalLinkage)
+			llvmInitFn.SetUnnamedAddr(true)
+			transform.AddStandardAttributes(llvmInitFn, config)
+			llvmInitFn.Param(0).SetName("context")
+			block := mod.Context().AddBasicBlock(llvmInitFn, "entry")
+			irbuilder := mod.Context().NewBuilder()
+			defer irbuilder.Dispose()
+			irbuilder.SetInsertPointAtEnd(block)
+			i8ptrType := llvm.PointerType(mod.Context().Int8Type(), 0)
+			for _, pkg := range lprogram.Sorted() {
+				pkgInit := mod.NamedFunction(pkg.Pkg.Path() + ".init")
+				if pkgInit.IsNil() {
+					panic("init not found for " + pkg.Pkg.Path())
+				}
+				irbuilder.CreateCall(pkgInit.GlobalValueType(), pkgInit, []llvm.Value{llvm.Undef(i8ptrType)}, "")
 			}
+			irbuilder.CreateRetVoid()
 
 			// After linking, functions should (as far as possible) be set to
 			// private linkage or internal linkage. The compiler package marks
@@ -555,7 +561,7 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 
 			// Run all optimization passes, which are much more effective now
 			// that the optimizer can see the whole program at once.
-			err = optimizeProgram(mod, config)
+			err := optimizeProgram(mod, config)
 			if err != nil {
 				return err
 			}
@@ -588,7 +594,12 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 			defer llvmBuf.Dispose()
 			return result, os.WriteFile(outpath, llvmBuf.Bytes(), 0666)
 		case ".bc":
-			buf := llvm.WriteThinLTOBitcodeToMemoryBuffer(mod)
+			var buf llvm.MemoryBuffer
+			if config.UseThinLTO() {
+				buf = llvm.WriteThinLTOBitcodeToMemoryBuffer(mod)
+			} else {
+				buf = llvm.WriteBitcodeToMemoryBuffer(mod)
+			}
 			defer buf.Dispose()
 			return result, os.WriteFile(outpath, buf.Bytes(), 0666)
 		case ".ll":
@@ -610,44 +621,23 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 		dependencies: []*compileJob{programJob},
 		result:       objfile,
 		run: func(*compileJob) error {
-			llvmBuf := llvm.WriteThinLTOBitcodeToMemoryBuffer(mod)
+			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
+				}
+			}
 			defer llvmBuf.Dispose()
 			return os.WriteFile(objfile, llvmBuf.Bytes(), 0666)
 		},
 	}
 
-	// Add job to create the runtime.initAll function in a new module.
-	initAllJob := &compileJob{
-		description: "create runtime.initAll",
-		result:      filepath.Join(tmpdir, "runtime-initAll.bc"),
-		run: func(job *compileJob) (err error) {
-			// Create module with runtime.initAll.
-			ctx := llvm.NewContext()
-			defer ctx.Dispose()
-			initAllMod := createInitAll(ctx, config, compilerConfig, lprogram.Sorted())
-			defer initAllMod.Dispose()
-
-			// Write module to bitcode file.
-			llvmBuf := llvm.WriteThinLTOBitcodeToMemoryBuffer(initAllMod)
-			defer llvmBuf.Dispose()
-			return os.WriteFile(job.result, llvmBuf.Bytes(), 0666)
-		},
-	}
-
 	// Prepare link command.
-	var linkerDependencies []*compileJob
-	switch config.LTO() {
-	case "legacy":
-		// Link all Go bitcode files together into a single large module and
-		// then do a ThinLTO link with the resulting large module + extra C
-		// files (from CGo etc).
-		linkerDependencies = append(linkerDependencies, outputObjectFileJob)
-	case "thin":
-		// Do a real thin link, with each Go package in a separate translation
-		// unit. This is faster than merging them into one big LTO module.
-		linkerDependencies = append(linkerDependencies, packageJobs...)
-		linkerDependencies = append(linkerDependencies, initAllJob)
-	}
+	linkerDependencies := []*compileJob{outputObjectFileJob}
 	result.Executable = filepath.Join(tmpdir, "main")
 	if config.GOOS() == "windows" {
 		result.Executable += ".exe"
@@ -674,7 +664,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.Options.PrintCommands)
+				result, err := compileAndCacheCFile(abspath, tmpdir, config.CFlags(), config.UseThinLTO(), config.Options.PrintCommands)
 				job.result = result
 				return err
 			},
@@ -692,7 +682,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.Options.PrintCommands)
+					result, err := compileAndCacheCFile(abspath, tmpdir, pkg.CFlags, config.UseThinLTO(), config.Options.PrintCommands)
 					job.result = result
 					return err
 				},
@@ -751,34 +741,36 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 				}
 				ldflags = append(ldflags, dependency.result)
 			}
-			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.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")
+				}
 			}
 			if config.Options.PrintCommands != nil {
 				config.Options.PrintCommands(config.Target.Linker, ldflags...)
@@ -1056,45 +1048,6 @@ func createEmbedObjectFile(data, hexSum, sourceFile, sourceDir, tmpdir string, c
 	return outfile.Name(), outfile.Close()
 }
 
-// Create a module with the runtime.initAll function that calls all package
-// initializers in initialization order.
-func createInitAll(ctx llvm.Context, config *compileopts.Config, compilerConfig *compiler.Config, pkgs []*loader.Package) llvm.Module {
-	// Create LLVM module.
-	mod := ctx.NewModule("runtime-initAll")
-
-	// Add datalayout string.
-	machine, err := compiler.NewTargetMachine(compilerConfig)
-	if err != nil {
-		panic(err) // extremely unlikely to fail here (NewTargetMachine is called many times before)
-	}
-	defer machine.Dispose()
-	targetData := machine.CreateTargetData()
-	defer targetData.Dispose()
-	mod.SetTarget(config.Triple())
-	mod.SetDataLayout(targetData.String())
-
-	// Create empty runtime.initAll function.
-	i8ptrType := llvm.PointerType(mod.Context().Int8Type(), 0)
-	fnType := llvm.FunctionType(ctx.VoidType(), []llvm.Type{i8ptrType}, false)
-	fn := llvm.AddFunction(mod, "runtime.initAll", fnType)
-	fn.SetUnnamedAddr(true)
-	transform.AddStandardAttributes(fn, config)
-
-	// Add calls to package initializers.
-	fn.Param(0).SetName("context")
-	block := mod.Context().AddBasicBlock(fn, "entry")
-	irbuilder := mod.Context().NewBuilder()
-	defer irbuilder.Dispose()
-	irbuilder.SetInsertPointAtEnd(block)
-	for _, pkg := range pkgs {
-		pkgInit := llvm.AddFunction(mod, pkg.Pkg.Path()+".init", fnType)
-		irbuilder.CreateCall(fnType, pkgInit, []llvm.Value{llvm.Undef(i8ptrType)}, "")
-	}
-	irbuilder.CreateRetVoid()
-
-	return mod
-}
-
 // optimizeProgram runs a series of optimizations and transformations that are
 // needed to convert a program to its final form. Some transformations are not
 // optional and must be run as the compiler expects them to run.
@@ -1116,6 +1069,10 @@ 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, printCommands func(string, ...string)) (string, error) {
+func compileAndCacheCFile(abspath, tmpdir string, cflags []string, thinlto bool, printCommands func(string, ...string)) (string, error) {
 	// Hash input file.
 	fileHash, err := hashFile(abspath)
 	if err != nil {
@@ -67,6 +67,11 @@ func compileAndCacheCFile(abspath, tmpdir string, cflags []string, printCommands
 	unlock := lock(filepath.Join(goenv.Get("GOCACHE"), fileHash+".c.lock"))
 	defer unlock()
 
+	ext := ".o"
+	if thinlto {
+		ext = ".bc"
+	}
+
 	// Create cache key for the dependencies file.
 	buf, err := json.Marshal(struct {
 		Path        string
@@ -99,7 +104,7 @@ func compileAndCacheCFile(abspath, tmpdir string, cflags []string, printCommands
 		}
 
 		// Obtain hashes of all the files listed as a dependency.
-		outpath, err := makeCFileCachePath(dependencies, depfileNameHash)
+		outpath, err := makeCFileCachePath(dependencies, depfileNameHash, ext)
 		if err == nil {
 			if _, err := os.Stat(outpath); err == nil {
 				return outpath, nil
@@ -112,7 +117,7 @@ func compileAndCacheCFile(abspath, tmpdir string, cflags []string, printCommands
 		return "", err
 	}
 
-	objTmpFile, err := os.CreateTemp(goenv.Get("GOCACHE"), "tmp-*.bc")
+	objTmpFile, err := os.CreateTemp(goenv.Get("GOCACHE"), "tmp-*"+ext)
 	if err != nil {
 		return "", err
 	}
@@ -122,8 +127,11 @@ func compileAndCacheCFile(abspath, tmpdir string, cflags []string, printCommands
 		return "", err
 	}
 	depTmpFile.Close()
-	flags := append([]string{}, cflags...)                                                 // copy cflags
-	flags = append(flags, "-MD", "-MV", "-MTdeps", "-MF", depTmpFile.Name(), "-flto=thin") // autogenerate dependencies
+	flags := append([]string{}, cflags...)                                   // copy cflags
+	flags = append(flags, "-MD", "-MV", "-MTdeps", "-MF", depTmpFile.Name()) // autogenerate dependencies
+	if thinlto {
+		flags = append(flags, "-flto=thin")
+	}
 	flags = append(flags, "-c", "-o", objTmpFile.Name(), abspath)
 	if strings.ToLower(filepath.Ext(abspath)) == ".s" {
 		// If this is an assembly file (.s or .S, lowercase or uppercase), then
@@ -181,7 +189,7 @@ func compileAndCacheCFile(abspath, tmpdir string, cflags []string, printCommands
 	}
 
 	// Move temporary object file to final location.
-	outpath, err := makeCFileCachePath(dependencySlice, depfileNameHash)
+	outpath, err := makeCFileCachePath(dependencySlice, depfileNameHash, ext)
 	if err != nil {
 		return "", err
 	}
@@ -196,7 +204,7 @@ func compileAndCacheCFile(abspath, tmpdir string, cflags []string, printCommands
 // Create a cache path (a path in GOCACHE) to store the output of a compiler
 // job. This path is based on the dep file name (which is a hash of metadata
 // including compiler flags) and the hash of all input files in the paths slice.
-func makeCFileCachePath(paths []string, depfileNameHash string) (string, error) {
+func makeCFileCachePath(paths []string, depfileNameHash, ext string) (string, error) {
 	// Hash all input files.
 	fileHashes := make(map[string]string, len(paths))
 	for _, path := range paths {
@@ -221,7 +229,7 @@ func makeCFileCachePath(paths []string, depfileNameHash string) (string, error)
 	outFileNameBuf := sha512.Sum512_224(buf)
 	cacheKey := hex.EncodeToString(outFileNameBuf[:])
 
-	outpath := filepath.Join(goenv.Get("GOCACHE"), "obj-"+cacheKey+".bc")
+	outpath := filepath.Join(goenv.Get("GOCACHE"), "obj-"+cacheKey+ext)
 	return outpath, nil
 }
 

builder/sizes.go

@@ -118,6 +118,10 @@ var (
 	//   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$`)
 )
 
 // readProgramSizeFromDWARF reads the source location for each line of code and
@@ -371,7 +375,7 @@ func loadProgramSize(path string, packagePathMap map[string]string) (*programSiz
 			if section.Flags&elf.SHF_ALLOC == 0 {
 				continue
 			}
-			if packageSymbolRegexp.MatchString(symbol.Name) {
+			if packageSymbolRegexp.MatchString(symbol.Name) || reflectDataRegexp.MatchString(symbol.Name) {
 				addresses = append(addresses, addressLine{
 					Address:    symbol.Value,
 					Length:     symbol.Size,
@@ -832,8 +836,9 @@ func findPackagePath(path string, packagePathMap map[string]string) string {
 		} else if packageSymbolRegexp.MatchString(path) {
 			// Parse symbol names like main$alloc or runtime$string.
 			packagePath = path[:strings.LastIndex(path, "$")]
-		} else if path == "<Go type>" {
-			packagePath = "Go types"
+		} else if reflectDataRegexp.MatchString(path) {
+			// Parse symbol names like reflect.structTypesSidetable.
+			packagePath = "Go reflect data"
 		} else if path == "<Go interface assert>" {
 			// Interface type assert, generated by the interface lowering pass.
 			packagePath = "Go interface assert"

compileopts/config.go

@@ -75,8 +75,7 @@ func (c *Config) GOARM() string {
 
 // BuildTags returns the complete list of build tags used during this build.
 func (c *Config) BuildTags() []string {
-	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()}...)
+	tags := append(c.Target.BuildTags, []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))
 	}
@@ -165,14 +164,6 @@ func (c *Config) OptLevels() (optLevel, sizeLevel int, inlinerThreshold uint) {
 	}
 }
 
-// LTO returns one of the possible LTO configurations: legacy or thin.
-func (c *Config) LTO() string {
-	if c.Options.LTO != "" {
-		return c.Options.LTO
-	}
-	return "legacy"
-}
-
 // PanicStrategy returns the panic strategy selected for this target. Valid
 // values are "print" (print the panic value, then exit) or "trap" (issue a trap
 // instruction).
@@ -199,6 +190,14 @@ 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 {
@@ -551,27 +550,3 @@ type TestConfig struct {
 	CompileTestBinary bool
 	// TODO: Filter the test functions to run, include verbose flag, etc
 }
-
-// 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

@@ -1,132 +0,0 @@
-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/options.go

@@ -14,7 +14,6 @@ var (
 	validPrintSizeOptions     = []string{"none", "short", "full"}
 	validPanicStrategyOptions = []string{"print", "trap"}
 	validOptOptions           = []string{"none", "0", "1", "2", "s", "z"}
-	validLTOOptions           = []string{"legacy", "thin"}
 )
 
 // Options contains extra options to give to the compiler. These options are
@@ -26,7 +25,6 @@ type Options struct {
 	GOARM           string // environment variable (only used with GOARCH=arm)
 	Target          string
 	Opt             string
-	LTO             string
 	GC              string
 	PanicStrategy   string
 	Scheduler       string
@@ -109,12 +107,6 @@ func (o *Options) Verify() error {
 		}
 	}
 
-	if o.LTO != "" {
-		if !isInArray(validLTOOptions, o.LTO) {
-			return fmt.Errorf("invalid -lto=%s: valid values are %s", o.LTO, strings.Join(validLTOOptions, ", "))
-		}
-	}
-
 	return nil
 }
 

compileopts/target.go

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

compiler/alias.go

@@ -34,9 +34,7 @@ var stdlibAliases = map[string]string{
 // createAlias implements the function (in the builder) as a call to the alias
 // function.
 func (b *builder) createAlias(alias llvm.Value) {
-	if !b.LTO {
-		b.llvmFn.SetVisibility(llvm.HiddenVisibility)
-	}
+	b.llvmFn.SetVisibility(llvm.HiddenVisibility)
 	b.llvmFn.SetUnnamedAddr(true)
 
 	if b.Debug {

compiler/compiler.go

@@ -47,7 +47,6 @@ 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
@@ -55,7 +54,6 @@ type Config struct {
 	DefaultStackSize   uint64
 	NeedsStackObjects  bool
 	Debug              bool // Whether to emit debug information in the LLVM module.
-	LTO                bool // non-legacy LTO (meaning: package bitcode is merged by the linker)
 }
 
 // compilerContext contains function-independent data that should still be
@@ -323,14 +321,6 @@ 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()
 	}
@@ -350,15 +340,12 @@ 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 {
-	return c.getLLVMType(c.getRuntimeType(name))
+	typ := c.runtimePkg.Scope().Lookup(name).(*types.TypeName).Type()
+	return c.getLLVMType(typ)
 }
 
 // getLLVMType returns a LLVM type for a Go type. It doesn't recreate already
@@ -898,9 +885,7 @@ func (c *compilerContext) createPackage(irbuilder llvm.Builder, pkg *ssa.Package
 				c.createEmbedGlobal(member, global, files)
 			} else if !info.extern {
 				global.SetInitializer(llvm.ConstNull(global.GlobalValueType()))
-				if !c.LTO {
-					global.SetVisibility(llvm.HiddenVisibility)
-				}
+				global.SetVisibility(llvm.HiddenVisibility)
 				if info.section != "" {
 					global.SetSection(info.section)
 				}
@@ -947,9 +932,7 @@ func (c *compilerContext) createEmbedGlobal(member *ssa.Global, global llvm.Valu
 		}
 		strObj := c.getEmbedFileString(files[0])
 		global.SetInitializer(strObj)
-		if !c.LTO {
-			global.SetVisibility(llvm.HiddenVisibility)
-		}
+		global.SetVisibility(llvm.HiddenVisibility)
 
 	case *types.Slice:
 		if typ.Elem().Underlying().(*types.Basic).Kind() != types.Byte {
@@ -973,9 +956,7 @@ func (c *compilerContext) createEmbedGlobal(member *ssa.Global, global llvm.Valu
 		sliceLen := llvm.ConstInt(c.uintptrType, file.Size, false)
 		sliceObj := c.ctx.ConstStruct([]llvm.Value{slicePtr, sliceLen, sliceLen}, false)
 		global.SetInitializer(sliceObj)
-		if !c.LTO {
-			global.SetVisibility(llvm.HiddenVisibility)
-		}
+		global.SetVisibility(llvm.HiddenVisibility)
 
 	case *types.Struct:
 		// Assume this is an embed.FS struct:
@@ -1058,9 +1039,7 @@ func (c *compilerContext) createEmbedGlobal(member *ssa.Global, global llvm.Valu
 		globalInitializer := llvm.ConstNull(c.getLLVMType(member.Type().(*types.Pointer).Elem()))
 		globalInitializer = c.builder.CreateInsertValue(globalInitializer, sliceGlobal, 0, "")
 		global.SetInitializer(globalInitializer)
-		if !c.LTO {
-			global.SetVisibility(llvm.HiddenVisibility)
-		}
+		global.SetVisibility(llvm.HiddenVisibility)
 		global.SetAlignment(c.targetData.ABITypeAlignment(globalInitializer.Type()))
 	}
 }
@@ -1107,8 +1086,7 @@ func (b *builder) createFunctionStart(intrinsic bool) {
 		// assertion error in llvm-project/llvm/include/llvm/IR/GlobalValue.h:236
 		// is thrown.
 		if b.llvmFn.Linkage() != llvm.InternalLinkage &&
-			b.llvmFn.Linkage() != llvm.PrivateLinkage &&
-			!b.LTO {
+			b.llvmFn.Linkage() != llvm.PrivateLinkage {
 			b.llvmFn.SetVisibility(llvm.HiddenVisibility)
 		}
 		b.llvmFn.SetUnnamedAddr(true)

compiler/compiler_test.go

@@ -49,7 +49,6 @@ 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

@@ -271,7 +271,7 @@ func (b *builder) createDefer(instr *ssa.Defer) {
 		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.i8ptrType, b.i8ptrType)
+		valueTypes = append(valueTypes, b.uintptrType, b.i8ptrType)
 		for _, arg := range instr.Call.Args {
 			val := b.getValue(arg)
 			values = append(values, val)
@@ -476,7 +476,7 @@ func (b *builder) createRunDefers() {
 				valueTypes = append(valueTypes, b.getFuncType(callback.Signature()))
 			} else {
 				//Expect typecode
-				valueTypes = append(valueTypes, b.i8ptrType, b.i8ptrType)
+				valueTypes = append(valueTypes, b.uintptrType, b.i8ptrType)
 			}
 
 			for _, arg := range callback.Args {

compiler/interface.go

@@ -6,7 +6,6 @@ package compiler
 // interface-lowering.go for more details.
 
 import (
-	"fmt"
 	"go/token"
 	"go/types"
 	"strconv"
@@ -16,49 +15,6 @@ 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
-)
-
 // 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
@@ -67,9 +23,10 @@ const (
 // 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})
-	itfType := b.getTypeCode(typ)
+	itfTypeCodeGlobal := b.getTypeCode(typ)
+	itfTypeCode := b.CreatePtrToInt(itfTypeCodeGlobal, b.uintptrType, "")
 	itf := llvm.Undef(b.getLLVMRuntimeType("_interface"))
-	itf = b.CreateInsertValue(itf, itfType, 0, "")
+	itf = b.CreateInsertValue(itf, itfTypeCode, 0, "")
 	itf = b.CreateInsertValue(itf, itfValue, 1, "")
 	return itf
 }
@@ -84,236 +41,118 @@ func (b *builder) extractValueFromInterface(itf llvm.Value, llvmType llvm.Type)
 }
 
 // getTypeCode returns a reference to a type code.
-// 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).
+// It returns a pointer to an external global which should be replaced with the
+// real type in the interface lowering pass.
 func (c *compilerContext) getTypeCode(typ types.Type) llvm.Value {
-	ms := c.program.MethodSets.MethodSet(typ)
-	hasMethodSet := ms.Len() != 0
-	if _, ok := typ.Underlying().(*types.Interface); ok {
-		hasMethodSet = false
-	}
 	globalName := "reflect/types.type:" + getTypeCodeName(typ)
 	global := c.mod.NamedGlobal(globalName)
 	if global.IsNil() {
-		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]),
-		}
+		// 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
 		switch typ := typ.(type) {
-		case *types.Basic:
-			typeFieldTypes = append(typeFieldTypes,
-				types.NewVar(token.NoPos, nil, "ptrTo", types.Typ[types.UnsafePointer]),
-			)
 		case *types.Named:
-			typeFieldTypes = append(typeFieldTypes,
-				types.NewVar(token.NoPos, nil, "ptrTo", types.Typ[types.UnsafePointer]),
-				types.NewVar(token.NoPos, nil, "underlying", types.Typ[types.UnsafePointer]),
-			)
-		case *types.Chan, *types.Slice:
-			typeFieldTypes = append(typeFieldTypes,
-				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, "elementType", types.Typ[types.UnsafePointer]),
-			)
-		case *types.Array:
-			typeFieldTypes = append(typeFieldTypes,
-				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, "ptrTo", types.Typ[types.UnsafePointer]),
-			)
-		case *types.Struct:
-			typeFieldTypes = append(typeFieldTypes,
-				types.NewVar(token.NoPos, nil, "numFields", types.Typ[types.Uint16]),
-				types.NewVar(token.NoPos, nil, "ptrTo", types.Typ[types.UnsafePointer]),
-				types.NewVar(token.NoPos, nil, "fields", types.NewArray(c.getRuntimeType("structField"), int64(typ.NumFields()))),
-			)
-		case *types.Interface:
-			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 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...)
-		}
-		globalType := types.NewStruct(typeFieldTypes, nil)
-		global = llvm.AddGlobal(c.mod, c.getLLVMType(globalType), globalName)
-		metabyte := getTypeKind(typ)
-		switch typ := typ.(type) {
-		case *types.Basic:
-			typeFields = []llvm.Value{c.getTypeCode(types.NewPointer(typ))}
-		case *types.Named:
-			typeFields = []llvm.Value{
-				c.getTypeCode(types.NewPointer(typ)), // ptrTo
-				c.getTypeCode(typ.Underlying()),      // underlying
-			}
-			metabyte |= 1 << 5 // "named" flag
+			references = c.getTypeCode(typ.Underlying())
 		case *types.Chan:
-			typeFields = []llvm.Value{
-				c.getTypeCode(types.NewPointer(typ)), // ptrTo
-				c.getTypeCode(typ.Elem()),            // elementType
-			}
-		case *types.Slice:
-			typeFields = []llvm.Value{
-				c.getTypeCode(types.NewPointer(typ)), // ptrTo
-				c.getTypeCode(typ.Elem()),            // elementType
-			}
+			references = c.getTypeCode(typ.Elem())
 		case *types.Pointer:
-			typeFields = []llvm.Value{c.getTypeCode(typ.Elem())}
+			references = c.getTypeCode(typ.Elem())
+		case *types.Slice:
+			references = c.getTypeCode(typ.Elem())
 		case *types.Array:
-			typeFields = []llvm.Value{
-				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{
-				c.getTypeCode(types.NewPointer(typ)), // ptrTo
-			}
+			references = c.getTypeCode(typ.Elem())
+			length = typ.Len()
 		case *types.Struct:
-			typeFields = []llvm.Value{
-				llvm.ConstInt(c.ctx.Int16Type(), uint64(typ.NumFields()), false), // numFields
-				c.getTypeCode(types.NewPointer(typ)),                             // ptrTo
-			}
-			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
-				}
-				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))
+			// Take a pointer to the typecodeID of the first field (if it exists).
+			structGlobal := c.makeStructTypeFields(typ)
+			references = llvm.ConstBitCast(structGlobal, global.Type())
 		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
+			methodSetGlobal := c.getInterfaceMethodSet(typ)
+			references = llvm.ConstBitCast(methodSetGlobal, global.Type())
 		}
-		// 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...)
+		if _, ok := typ.Underlying().(*types.Interface); !ok {
+			methodSet = c.getTypeMethodSet(typ)
+		} else {
+			typeAssert = c.getInterfaceImplementsFunc(typ)
+			typeAssert = llvm.ConstPtrToInt(typeAssert, c.uintptrType)
+		}
+		if _, ok := typ.Underlying().(*types.Pointer); !ok {
+			ptrTo = c.getTypeCode(types.NewPointer(typ))
+		}
+		globalValue := llvm.ConstNull(global.GlobalValueType())
+		if !references.IsNil() {
+			globalValue = c.builder.CreateInsertValue(globalValue, references, 0, "")
+		}
+		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, "")
 		}
-		alignment := c.targetData.TypeAllocSize(c.i8ptrType)
-		globalValue := c.ctx.ConstStruct(typeFields, false)
 		global.SetInitializer(globalValue)
 		global.SetLinkage(llvm.LinkOnceODRLinkage)
 		global.SetGlobalConstant(true)
-		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),
+	}
+	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.AddMetadata(0, diglobal)
+			fieldGlobalValue = c.builder.CreateInsertValue(fieldGlobalValue, fieldTag, 2, "")
 		}
+		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, "")
 	}
-	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),
-	})
+	structGlobal.SetInitializer(structGlobalValue)
+	structGlobal.SetUnnamedAddr(true)
+	structGlobal.SetLinkage(llvm.PrivateLinkage)
+	return structGlobal
 }
 
-// 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{
+var basicTypes = [...]string{
 	types.Bool:          "bool",
 	types.Int:           "int",
 	types.Int8:          "int8",
@@ -344,7 +183,7 @@ func getTypeCodeName(t types.Type) string {
 	case *types.Array:
 		return "array:" + strconv.FormatInt(t.Len(), 10) + ":" + getTypeCodeName(t.Elem())
 	case *types.Basic:
-		return "basic:" + basicTypeNames[t.Kind()]
+		return "basic:" + basicTypes[t.Kind()]
 	case *types.Chan:
 		return "chan:" + getTypeCodeName(t.Elem())
 	case *types.Interface:
@@ -396,40 +235,75 @@ 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 {
-	globalName := typ.String() + "$methodset"
-	global := c.mod.NamedGlobal(globalName)
-	if global.IsNil() {
-		ms := c.program.MethodSets.MethodSet(typ)
-
-		// 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)
-		}
-
-		// 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(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})
 	}
-	return global
+
+	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)
+		}
+		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
+	}
+	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})
 }
 
 // getMethodSignatureName returns a unique name (that can be used as the name of
@@ -490,22 +364,17 @@ func (b *builder) createTypeAssert(expr *ssa.TypeAssert) llvm.Value {
 		commaOk = b.CreateCall(fn.GlobalValueType(), fn, []llvm.Value{actualTypeNum}, "")
 
 	} else {
-		if b.LTO {
-			assertedTypeCodeGlobal := b.getTypeCode(expr.AssertedType)
-			commaOk = b.CreateICmp(llvm.IntEQ, actualTypeNum, assertedTypeCodeGlobal, "commaok")
-		} else {
-			globalName := "reflect/types.typeid:" + getTypeCodeName(expr.AssertedType)
-			assertedTypeCodeGlobal := b.mod.NamedGlobal(globalName)
-			if assertedTypeCodeGlobal.IsNil() {
-				// Create a new typecode global.
-				assertedTypeCodeGlobal = llvm.AddGlobal(b.mod, b.ctx.Int8Type(), globalName)
-				assertedTypeCodeGlobal.SetGlobalConstant(true)
-			}
-			// Type assert on concrete type.
-			// Call runtime.typeAssert, which will be lowered to a simple icmp
-			// or const false in the interface lowering pass.
-			commaOk = b.createRuntimeCall("typeAssert", []llvm.Value{actualTypeNum, assertedTypeCodeGlobal}, "typecode")
+		globalName := "reflect/types.typeid:" + getTypeCodeName(expr.AssertedType)
+		assertedTypeCodeGlobal := b.mod.NamedGlobal(globalName)
+		if assertedTypeCodeGlobal.IsNil() {
+			// Create a new typecode global.
+			assertedTypeCodeGlobal = llvm.AddGlobal(b.mod, b.ctx.Int8Type(), globalName)
+			assertedTypeCodeGlobal.SetGlobalConstant(true)
 		}
+		// Type assert on concrete type.
+		// Call runtime.typeAssert, which will be lowered to a simple icmp or
+		// const false in the interface lowering pass.
+		commaOk = b.createRuntimeCall("typeAssert", []llvm.Value{actualTypeNum, assertedTypeCodeGlobal}, "typecode")
 	}
 
 	// Add 2 new basic blocks (that should get optimized away): one for the
@@ -574,7 +443,7 @@ func (c *compilerContext) getInterfaceImplementsFunc(assertedType types.Type) ll
 	fnName := getTypeCodeName(assertedType.Underlying()) + ".$typeassert"
 	llvmFn := c.mod.NamedFunction(fnName)
 	if llvmFn.IsNil() {
-		llvmFnType := llvm.FunctionType(c.ctx.Int1Type(), []llvm.Type{c.i8ptrType}, false)
+		llvmFnType := llvm.FunctionType(c.ctx.Int1Type(), []llvm.Type{c.uintptrType}, false)
 		llvmFn = llvm.AddFunction(c.mod, fnName, llvmFnType)
 		c.addStandardDeclaredAttributes(llvmFn)
 		methods := c.getMethodsString(assertedType.Underlying().(*types.Interface))
@@ -595,7 +464,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.UnsafePointer]))
+		paramTuple = append(paramTuple, types.NewVar(token.NoPos, nil, "$typecode", types.Typ[types.Uintptr]))
 		llvmFnType := c.getRawFuncType(types.NewSignature(sig.Recv(), types.NewTuple(paramTuple...), sig.Results(), false))
 		llvmFn = llvm.AddFunction(c.mod, fnName, llvmFnType)
 		c.addStandardDeclaredAttributes(llvmFn)
@@ -732,7 +601,7 @@ func typestring(t types.Type) string {
 	case *types.Array:
 		return "[" + strconv.FormatInt(t.Len(), 10) + "]" + typestring(t.Elem())
 	case *types.Basic:
-		return basicTypeNames[t.Kind()]
+		return basicTypes[t.Kind()]
 	case *types.Chan:
 		switch t.Dir() {
 		case types.SendRecv:

compiler/interrupt.go

@@ -45,9 +45,7 @@ func (b *builder) createInterruptGlobal(instr *ssa.CallCommon) (llvm.Value, erro
 	globalLLVMType := b.getLLVMType(globalType)
 	globalName := b.fn.Package().Pkg.Path() + "$interrupt" + strconv.FormatInt(id.Int64(), 10)
 	global := llvm.AddGlobal(b.mod, globalLLVMType, globalName)
-	if !b.LTO {
-		global.SetVisibility(llvm.HiddenVisibility)
-	}
+	global.SetVisibility(llvm.HiddenVisibility)
 	global.SetGlobalConstant(true)
 	global.SetUnnamedAddr(true)
 	initializer := llvm.ConstNull(globalLLVMType)

compiler/intrinsics.go

@@ -24,8 +24,6 @@ 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"):
@@ -89,29 +87,6 @@ func (b *builder) createMemoryZeroImpl() {
 	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])
-	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",

compiler/map.go

@@ -89,7 +89,6 @@ 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, "")
@@ -134,7 +133,6 @@ 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)
@@ -163,7 +161,6 @@ 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)
@@ -243,8 +240,7 @@ 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.  Note that padding bytes are undef
-// and can alter two "equal" structs being equal when compared with memequal.
+// can be compared with runtime.memequal.
 func hashmapIsBinaryKey(keyType types.Type) bool {
 	switch keyType := keyType.(type) {
 	case *types.Basic:
@@ -267,76 +263,3 @@ 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/testdata/defer-cortex-m-qemu.ll

@@ -4,7 +4,7 @@ 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 { ptr, ptr }
+%runtime._interface = type { i32, ptr }
 %runtime._defer = type { i32, ptr }
 
 declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #0

compiler/testdata/gc.ll

@@ -3,7 +3,8 @@ 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._interface = type { ptr, ptr }
+%runtime.typecodeID = type { ptr, i32, ptr, ptr, i32 }
+%runtime._interface = type { i32, ptr }
 
 @main.scalar1 = hidden global ptr null, align 4
 @main.scalar2 = hidden global ptr null, align 4
@@ -21,8 +22,8 @@ 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 { i8, ptr } { i8 16, ptr @"reflect/types.type:pointer:basic:complex128" }, align 4
-@"reflect/types.type:pointer:basic:complex128" = linkonce_odr constant { i8, ptr } { i8 21, ptr @"reflect/types.type:basic:complex128" }, align 4
+@"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 }
 
 declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #0
 
@@ -128,8 +129,7 @@ entry:
   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 { 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) #2
+  %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
   ret %runtime._interface %1
 }

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

@@ -145,34 +145,34 @@ entry:
 declare void @runtime.chanClose(ptr dereferenceable_or_null(32), ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.startInterfaceMethod(ptr %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
+define hidden void @main.startInterfaceMethod(i32 %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
 entry:
   %0 = call ptr @runtime.alloc(i32 16, ptr null, ptr undef) #8
   store ptr %itf.value, ptr %0, align 4
-  %1 = getelementptr inbounds { ptr, %runtime._string, ptr }, ptr %0, i32 0, i32 1
+  %1 = getelementptr inbounds { ptr, %runtime._string, i32 }, ptr %0, i32 0, i32 1
   store ptr @"main$string", ptr %1, align 4
-  %.repack1 = getelementptr inbounds { ptr, %runtime._string, ptr }, ptr %0, i32 0, i32 1, i32 1
+  %.repack1 = getelementptr inbounds { ptr, %runtime._string, i32 }, ptr %0, i32 0, i32 1, i32 1
   store i32 4, ptr %.repack1, align 4
-  %2 = getelementptr inbounds { ptr, %runtime._string, ptr }, ptr %0, i32 0, i32 2
-  store ptr %itf.typecode, ptr %2, 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
   ret void
 }
 
-declare void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(ptr, ptr, i32, ptr, ptr) #6
+declare void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(ptr, ptr, i32, i32, ptr) #6
 
 ; Function Attrs: nounwind
 define linkonce_odr void @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper"(ptr %0) unnamed_addr #7 {
 entry:
   %1 = load ptr, ptr %0, align 4
-  %2 = getelementptr inbounds { ptr, ptr, i32, ptr }, ptr %0, i32 0, i32 1
+  %2 = getelementptr inbounds { ptr, ptr, i32, i32 }, ptr %0, i32 0, i32 1
   %3 = load ptr, ptr %2, align 4
-  %4 = getelementptr inbounds { ptr, ptr, i32, ptr }, ptr %0, i32 0, i32 2
+  %4 = getelementptr inbounds { ptr, ptr, i32, i32 }, ptr %0, i32 0, i32 2
   %5 = load i32, ptr %4, align 4
-  %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) #8
+  %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
   ret void
 }
 

compiler/testdata/goroutine-wasm-asyncify.ll

@@ -154,35 +154,35 @@ entry:
 declare void @runtime.chanClose(ptr dereferenceable_or_null(32), ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.startInterfaceMethod(ptr %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
+define hidden void @main.startInterfaceMethod(i32 %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
 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
   store ptr %itf.value, ptr %0, align 4
-  %1 = getelementptr inbounds { ptr, %runtime._string, ptr }, ptr %0, i32 0, i32 1
+  %1 = getelementptr inbounds { ptr, %runtime._string, i32 }, ptr %0, i32 0, i32 1
   store ptr @"main$string", ptr %1, align 4
-  %.repack1 = getelementptr inbounds { ptr, %runtime._string, ptr }, ptr %0, i32 0, i32 1, i32 1
+  %.repack1 = getelementptr inbounds { ptr, %runtime._string, i32 }, ptr %0, i32 0, i32 1, i32 1
   store i32 4, ptr %.repack1, align 4
-  %2 = getelementptr inbounds { ptr, %runtime._string, ptr }, ptr %0, i32 0, i32 2
-  store ptr %itf.typecode, ptr %2, 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
   ret void
 }
 
-declare void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(ptr, ptr, i32, ptr, ptr) #6
+declare void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(ptr, ptr, i32, i32, ptr) #6
 
 ; Function Attrs: nounwind
 define linkonce_odr void @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper"(ptr %0) unnamed_addr #7 {
 entry:
   %1 = load ptr, ptr %0, align 4
-  %2 = getelementptr inbounds { ptr, ptr, i32, ptr }, ptr %0, i32 0, i32 1
+  %2 = getelementptr inbounds { ptr, ptr, i32, i32 }, ptr %0, i32 0, i32 1
   %3 = load ptr, ptr %2, align 4
-  %4 = getelementptr inbounds { ptr, ptr, i32, ptr }, ptr %0, i32 0, i32 2
+  %4 = getelementptr inbounds { ptr, ptr, i32, i32 }, ptr %0, i32 0, i32 2
   %5 = load i32, ptr %4, align 4
-  %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) #8
+  %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
   unreachable
 }

compiler/testdata/interface.ll

@@ -3,17 +3,22 @@ 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._interface = type { ptr, ptr }
+%runtime.typecodeID = type { ptr, i32, ptr, ptr, i32 }
+%runtime._interface = type { i32, ptr }
 %runtime._string = type { ptr, i32 }
 
-@"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, ptr } { i8 21, ptr @"reflect/types.type:basic:int" }, align 4
-@"reflect/types.type:pointer:named:error" = linkonce_odr constant { i8, ptr } { i8 21, ptr @"reflect/types.type:named:error" }, align 4
-@"reflect/types.type:named:error" = linkonce_odr constant { i8, ptr, ptr } { i8 52, ptr @"reflect/types.type:pointer:named:error", ptr @"reflect/types.type:interface:{Error:func:{}{basic:string}}" }, align 4
-@"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, ptr } { i8 21, ptr @"reflect/types.type:interface:{Error:func:{}{basic:string}}" }, align 4
-@"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}" = linkonce_odr constant { i8, ptr } { i8 21, 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.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.typeid:basic:int" = external constant i8
 
 declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #0
@@ -30,42 +35,42 @@ entry:
 define hidden %runtime._interface @main.simpleType(ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
-  call void @runtime.trackPointer(ptr nonnull @"reflect/types.type:basic:int", ptr nonnull %stackalloc, ptr undef) #6
   call void @runtime.trackPointer(ptr null, ptr nonnull %stackalloc, ptr undef) #6
-  ret %runtime._interface { ptr @"reflect/types.type:basic:int", ptr null }
+  ret %runtime._interface { i32 ptrtoint (ptr @"reflect/types.type:basic:int" to i32), ptr null }
 }
 
 ; Function Attrs: nounwind
 define hidden %runtime._interface @main.pointerType(ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
-  call void @runtime.trackPointer(ptr nonnull @"reflect/types.type:pointer:basic:int", ptr nonnull %stackalloc, ptr undef) #6
   call void @runtime.trackPointer(ptr null, ptr nonnull %stackalloc, ptr undef) #6
-  ret %runtime._interface { ptr @"reflect/types.type:pointer:basic:int", ptr null }
+  ret %runtime._interface { i32 ptrtoint (ptr @"reflect/types.type:pointer:basic:int" to i32), ptr null }
 }
 
 ; Function Attrs: nounwind
 define hidden %runtime._interface @main.interfaceType(ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
-  call void @runtime.trackPointer(ptr nonnull @"reflect/types.type:pointer:named:error", ptr nonnull %stackalloc, ptr undef) #6
   call void @runtime.trackPointer(ptr null, ptr nonnull %stackalloc, ptr undef) #6
-  ret %runtime._interface { ptr @"reflect/types.type:pointer:named:error", ptr null }
+  ret %runtime._interface { i32 ptrtoint (ptr @"reflect/types.type:pointer:named:error" to i32), 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 {
 entry:
   %stackalloc = alloca i8, align 1
-  call void @runtime.trackPointer(ptr nonnull @"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}", ptr nonnull %stackalloc, ptr undef) #6
   call void @runtime.trackPointer(ptr null, ptr nonnull %stackalloc, ptr undef) #6
-  ret %runtime._interface { ptr @"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}", ptr null }
+  ret %runtime._interface { i32 ptrtoint (ptr @"reflect/types.type:pointer:interface:{String:func:{}{basic:string}}" to i32), ptr null }
 }
 
+declare i1 @"interface:{String:func:{}{basic:string}}.$typeassert"(i32) #3
+
 ; Function Attrs: nounwind
-define hidden i1 @main.isInt(ptr %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
+define hidden i1 @main.isInt(i32 %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
 entry:
-  %typecode = call i1 @runtime.typeAssert(ptr %itf.typecode, ptr nonnull @"reflect/types.typeid:basic:int", ptr undef) #6
+  %typecode = call i1 @runtime.typeAssert(i32 %itf.typecode, ptr nonnull @"reflect/types.typeid:basic:int", ptr undef) #6
   br i1 %typecode, label %typeassert.ok, label %typeassert.next
 
 typeassert.next:                                  ; preds = %typeassert.ok, %entry
@@ -75,12 +80,12 @@ typeassert.ok:                                    ; preds = %entry
   br label %typeassert.next
 }
 
-declare i1 @runtime.typeAssert(ptr, ptr dereferenceable_or_null(1), ptr) #0
+declare i1 @runtime.typeAssert(i32, ptr dereferenceable_or_null(1), ptr) #0
 
 ; Function Attrs: nounwind
-define hidden i1 @main.isError(ptr %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
+define hidden i1 @main.isError(i32 %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
 entry:
-  %0 = call i1 @"interface:{Error:func:{}{basic:string}}.$typeassert"(ptr %itf.typecode) #6
+  %0 = call i1 @"interface:{Error:func:{}{basic:string}}.$typeassert"(i32 %itf.typecode) #6
   br i1 %0, label %typeassert.ok, label %typeassert.next
 
 typeassert.next:                                  ; preds = %typeassert.ok, %entry
@@ -90,12 +95,10 @@ typeassert.ok:                                    ; preds = %entry
   br label %typeassert.next
 }
 
-declare i1 @"interface:{Error:func:{}{basic:string}}.$typeassert"(ptr) #2
-
 ; Function Attrs: nounwind
-define hidden i1 @main.isStringer(ptr %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
+define hidden i1 @main.isStringer(i32 %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
 entry:
-  %0 = call i1 @"interface:{String:func:{}{basic:string}}.$typeassert"(ptr %itf.typecode) #6
+  %0 = call i1 @"interface:{String:func:{}{basic:string}}.$typeassert"(i32 %itf.typecode) #6
   br i1 %0, label %typeassert.ok, label %typeassert.next
 
 typeassert.next:                                  ; preds = %typeassert.ok, %entry
@@ -105,28 +108,26 @@ typeassert.ok:                                    ; preds = %entry
   br label %typeassert.next
 }
 
-declare i1 @"interface:{String:func:{}{basic:string}}.$typeassert"(ptr) #3
-
 ; Function Attrs: nounwind
-define hidden i8 @main.callFooMethod(ptr %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
+define hidden i8 @main.callFooMethod(i32 %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
 entry:
-  %0 = call i8 @"interface:{String:func:{}{basic:string},main.foo:func:{basic:int}{basic:uint8}}.foo$invoke"(ptr %itf.value, i32 3, ptr %itf.typecode, ptr undef) #6
+  %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
   ret i8 %0
 }
 
-declare i8 @"interface:{String:func:{}{basic:string},main.foo:func:{basic:int}{basic:uint8}}.foo$invoke"(ptr, i32, ptr, ptr) #4
+declare i8 @"interface:{String:func:{}{basic:string},main.foo:func:{basic:int}{basic:uint8}}.foo$invoke"(ptr, i32, i32, ptr) #4
 
 ; Function Attrs: nounwind
-define hidden %runtime._string @main.callErrorMethod(ptr %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
+define hidden %runtime._string @main.callErrorMethod(i32 %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
 entry:
   %stackalloc = alloca i8, align 1
-  %0 = call %runtime._string @"interface:{Error:func:{}{basic:string}}.Error$invoke"(ptr %itf.value, ptr %itf.typecode, ptr undef) #6
+  %0 = call %runtime._string @"interface:{Error:func:{}{basic:string}}.Error$invoke"(ptr %itf.value, i32 %itf.typecode, ptr undef) #6
   %1 = extractvalue %runtime._string %0, 0
   call void @runtime.trackPointer(ptr %1, ptr nonnull %stackalloc, ptr undef) #6
   ret %runtime._string %0
 }
 
-declare %runtime._string @"interface:{Error:func:{}{basic:string}}.Error$invoke"(ptr, ptr, ptr) #5
+declare %runtime._string @"interface:{Error:func:{}{basic:string}}.Error$invoke"(ptr, i32, ptr) #5
 
 attributes #0 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
 attributes #1 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }

compiler/testdata/zeromap.go

@@ -1,37 +0,0 @@
-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

@@ -1,170 +0,0 @@
-; 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 }
-
-declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #0
-
-declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #0
-
-; Function Attrs: nounwind
-define hidden void @main.init(ptr %context) unnamed_addr #1 {
-entry:
-  ret void
-}
-
-; Function Attrs: noinline nounwind
-define hidden i32 @main.testZeroGet(ptr dereferenceable_or_null(40) %m, i1 %s.b1, i32 %s.i, i1 %s.b2, ptr %context) unnamed_addr #2 {
-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) #4
-  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) #4
-  %4 = getelementptr inbounds i8, ptr %hashmap.key, i32 9
-  call void @runtime.memzero(ptr nonnull %4, i32 3, ptr undef) #4
-  %5 = call i1 @runtime.hashmapBinaryGet(ptr %m, ptr nonnull %hashmap.key, ptr nonnull %hashmap.value, i32 4, ptr undef) #4
-  call void @llvm.lifetime.end.p0(i64 12, ptr nonnull %hashmap.key)
-  %6 = load i32, ptr %hashmap.value, align 4
-  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) #3
-
-declare void @runtime.memzero(ptr, i32, ptr) #0
-
-declare i1 @runtime.hashmapBinaryGet(ptr dereferenceable_or_null(40), ptr, ptr, i32, ptr) #0
-
-; Function Attrs: argmemonly nocallback nofree nosync nounwind willreturn
-declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #3
-
-; Function Attrs: noinline nounwind
-define hidden void @main.testZeroSet(ptr dereferenceable_or_null(40) %m, i1 %s.b1, i32 %s.i, i1 %s.b2, ptr %context) unnamed_addr #2 {
-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) #4
-  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) #4
-  %4 = getelementptr inbounds i8, ptr %hashmap.key, i32 9
-  call void @runtime.memzero(ptr nonnull %4, i32 3, ptr undef) #4
-  call void @runtime.hashmapBinarySet(ptr %m, ptr nonnull %hashmap.key, ptr nonnull %hashmap.value, ptr undef) #4
-  call void @llvm.lifetime.end.p0(i64 12, ptr nonnull %hashmap.key)
-  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %hashmap.value)
-  ret void
-}
-
-declare void @runtime.hashmapBinarySet(ptr dereferenceable_or_null(40), ptr, ptr, ptr) #0
-
-; Function Attrs: noinline nounwind
-define hidden i32 @main.testZeroArrayGet(ptr dereferenceable_or_null(40) %m, [2 x %main.hasPadding] %s, ptr %context) unnamed_addr #2 {
-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) #4
-  %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) #4
-  %1 = getelementptr inbounds i8, ptr %hashmap.key, i32 9
-  call void @runtime.memzero(ptr nonnull %1, i32 3, ptr undef) #4
-  %2 = getelementptr inbounds i8, ptr %hashmap.key, i32 13
-  call void @runtime.memzero(ptr nonnull %2, i32 3, ptr undef) #4
-  %3 = getelementptr inbounds i8, ptr %hashmap.key, i32 21
-  call void @runtime.memzero(ptr nonnull %3, i32 3, ptr undef) #4
-  %4 = call i1 @runtime.hashmapBinaryGet(ptr %m, ptr nonnull %hashmap.key, ptr nonnull %hashmap.value, i32 4, ptr undef) #4
-  call void @llvm.lifetime.end.p0(i64 24, ptr nonnull %hashmap.key)
-  %5 = load i32, ptr %hashmap.value, align 4
-  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 #2 {
-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) #4
-  %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) #4
-  %1 = getelementptr inbounds i8, ptr %hashmap.key, i32 9
-  call void @runtime.memzero(ptr nonnull %1, i32 3, ptr undef) #4
-  %2 = getelementptr inbounds i8, ptr %hashmap.key, i32 13
-  call void @runtime.memzero(ptr nonnull %2, i32 3, ptr undef) #4
-  %3 = getelementptr inbounds i8, ptr %hashmap.key, i32 21
-  call void @runtime.memzero(ptr nonnull %3, i32 3, ptr undef) #4
-  call void @runtime.hashmapBinarySet(ptr %m, ptr nonnull %hashmap.key, ptr nonnull %hashmap.value, ptr undef) #4
-  call void @llvm.lifetime.end.p0(i64 24, ptr nonnull %hashmap.key)
-  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %hashmap.value)
-  ret void
-}
-
-; Function Attrs: nounwind
-define hidden void @main.main(ptr %context) unnamed_addr #1 {
-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 = { noinline nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
-attributes #3 = { argmemonly nocallback nofree nosync nounwind willreturn }
-attributes #4 = { nounwind }

go.mod

@@ -15,7 +15,7 @@ require (
 	github.com/mattn/go-tty v0.0.4
 	go.bug.st/serial v1.3.5
 	golang.org/x/sys v0.4.0
-	golang.org/x/tools v0.5.1-0.20230114154351-e035d0c426c8
+	golang.org/x/tools v0.5.0
 	gopkg.in/yaml.v2 v2.4.0
 	tinygo.org/x/go-llvm v0.0.0-20221028183034-8341240c0b32
 )

go.sum

@@ -56,8 +56,8 @@ golang.org/x/sys v0.0.0-20201207223542-d4d67f95c62d/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20211124211545-fe61309f8881/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.4.0 h1:Zr2JFtRQNX3BCZ8YtxRE9hNJYC8J6I1MVbMg6owUp18=
 golang.org/x/sys v0.4.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/tools v0.5.1-0.20230114154351-e035d0c426c8 h1:LHoToPgySGSr2NcUHbjENAidHz38RkKaNmmntwn9TjI=
-golang.org/x/tools v0.5.1-0.20230114154351-e035d0c426c8/go.mod h1:N+Kgy78s5I24c24dU8OfWNEotWjutIs8SnJvn5IDq+k=
+golang.org/x/tools v0.5.0 h1:+bSpV5HIeWkuvgaMfI3UmKRThoTA5ODJTUd8T17NO+4=
+golang.org/x/tools v0.5.0/go.mod h1:N+Kgy78s5I24c24dU8OfWNEotWjutIs8SnJvn5IDq+k=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=

goenv/version.go

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

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" || callFn.name == "runtime.hashmapInterfaceHash" ||
+			case strings.HasPrefix(callFn.name, "runtime.print") || callFn.name == "runtime._panic" || callFn.name == "runtime.hashmapGet" ||
 				callFn.name == "os.runtime_args" || callFn.name == "internal/task.start" || callFn.name == "internal/task.Current":
 				// These functions should be run at runtime. Specifically:
 				//   * Print and panic functions are best emitted directly without
@@ -378,6 +378,42 @@ 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.
@@ -388,22 +424,15 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				if err != nil {
 					return nil, mem, r.errorAt(inst, err)
 				}
-				actualType, err := operands[1].toLLVMValue(inst.llvmInst.Operand(0).Type(), &mem)
+				actualTypePtrToInt, err := operands[1].toLLVMValue(inst.llvmInst.Operand(0).Type(), &mem)
 				if err != nil {
 					return nil, mem, r.errorAt(inst, err)
 				}
-				if !actualType.IsAConstantInt().IsNil() && actualType.ZExtValue() == 0 {
+				if !actualTypePtrToInt.IsAConstantInt().IsNil() && actualTypePtrToInt.ZExtValue() == 0 {
 					locals[inst.localIndex] = literalValue{uint8(0)}
 					break
 				}
-				// Strip pointer casts (bitcast, getelementptr).
-				for !actualType.IsAConstantExpr().IsNil() {
-					opcode := actualType.Opcode()
-					if opcode != llvm.GetElementPtr && opcode != llvm.BitCast {
-						break
-					}
-					actualType = actualType.Operand(0)
-				}
+				actualType := actualTypePtrToInt.Operand(0)
 				if strings.TrimPrefix(actualType.Name(), "reflect/types.type:") == strings.TrimPrefix(assertedType.Name(), "reflect/types.typeid:") {
 					locals[inst.localIndex] = literalValue{uint8(1)}
 				} else {
@@ -419,12 +448,11 @@ 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(-int64(r.pointerSize)), r.pointerSize).asPointer(r)
+				methodSetPtr, err := mem.load(typecodePtr.addOffset(r.pointerSize*2), 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()
@@ -432,9 +460,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 < numMethods; i++ {
-					methodInfo := r.builder.CreateExtractValue(methodSet, 1, "")
-					name := r.builder.CreateExtractValue(methodInfo, i, "").Name()
+				for i := 0; i < methodSet.Type().ArrayLength(); i++ {
+					methodInfo := r.builder.CreateExtractValue(methodSet, i, "")
+					name := r.builder.CreateExtractValue(methodInfo, 0, "").Name()
 					concreteTypeMethods[name] = struct{}{}
 				}
 
@@ -460,16 +488,15 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 					fmt.Fprintln(os.Stderr, indent+"invoke method:", operands[1:])
 				}
 
-				// Load the type code and method set of the interface value.
-				typecodePtr, err := operands[len(operands)-2].asPointer(r)
+				// Load the type code of the interface value.
+				typecodeIDBitCast, err := operands[len(operands)-2].toLLVMValue(inst.llvmInst.Operand(len(operands)-3).Type(), &mem)
 				if err != nil {
 					return nil, mem, r.errorAt(inst, err)
 				}
-				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()
+				typecodeID := typecodeIDBitCast.Operand(0).Initializer()
+
+				// Load the method set, which is part of the typecodeID object.
+				methodSet := stripPointerCasts(r.builder.CreateExtractValue(typecodeID, 2, "")).Initializer()
 
 				// We don't need to load the interface method set.
 
@@ -481,14 +508,13 @@ 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 := int(r.builder.CreateExtractValue(methodSet, 0, "").ZExtValue())
+				numMethods := methodSet.Type().ArrayLength()
 				var method llvm.Value
 				for i := 0; i < numMethods; i++ {
-					methodSignatureAgg := r.builder.CreateExtractValue(methodSet, 1, "")
-					methodSignature := r.builder.CreateExtractValue(methodSignatureAgg, i, "")
+					methodSignatureAgg := r.builder.CreateExtractValue(methodSet, i, "")
+					methodSignature := r.builder.CreateExtractValue(methodSignatureAgg, 0, "")
 					if methodSignature == signature {
-						methodAgg := r.builder.CreateExtractValue(methodSet, 2, "")
-						method = r.builder.CreateExtractValue(methodAgg, i, "")
+						method = r.builder.CreateExtractValue(methodSignatureAgg, 1, "").Operand(0)
 					}
 				}
 				if method.IsNil() {
@@ -659,7 +685,7 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				}
 				continue
 			}
-			ptr = ptr.addOffset(int64(offset))
+			ptr = ptr.addOffset(uint32(offset))
 			locals[inst.localIndex] = ptr
 			if r.debug {
 				fmt.Fprintln(os.Stderr, indent+"gep:", operands, "->", ptr)
@@ -758,7 +784,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(int64(rhs.Uint()))
+					lhsPtr = lhsPtr.addOffset(uint32(rhs.Uint()))
 					locals[inst.localIndex] = lhsPtr
 					continue
 				case llvm.Xor:

interp/memory.go

@@ -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 int64) pointerValue {
+func (v pointerValue) addOffset(offset uint32) 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.funcValueWithSignature" {
+					if name == "runtime.typecodeID" || name == "runtime.funcValueWithSignature" {
 						uintptrType := ctx.IntType(int(mem.r.pointerSize) * 8)
 						field = llvm.ConstPtrToInt(field, uintptrType)
 					}

interp/testdata/interface.ll

@@ -1,16 +1,17 @@
 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 { 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.type:named:main.foo" = private constant %runtime.typecodeID { %runtime.typecodeID* @"reflect/types.type:basic:int", i64 0, %runtime.interfaceMethodInfo* null }
 @"reflect/types.typeid:named:main.foo" = external constant i8
-@"reflect/types.type:basic:int" = 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* }
+@"reflect/types.type:basic:int" = external constant %runtime.typecodeID
 
 
-declare i1 @runtime.typeAssert(i8*, i8*, i8*, i8*)
+declare i1 @runtime.typeAssert(i64, i8*, i8*, i8*)
 
 define void @runtime.initAll() unnamed_addr {
 entry:
@@ -21,9 +22,9 @@ entry:
 define internal void @main.init() unnamed_addr {
 entry:
   ; Test type asserts.
-  %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)
+  %typecode = call i1 @runtime.typeAssert(i64 ptrtoint (%runtime.typecodeID* @"reflect/types.type:named:main.foo" to i64), i8* @"reflect/types.typeid:named:main.foo", i8* undef, i8* null)
   store i1 %typecode, i1* @main.v1
-  %typecode2 = call i1 @runtime.typeAssert(i8* null, i8* @"reflect/types.typeid:named:main.foo", i8* undef, i8* null)
+  %typecode2 = call i1 @runtime.typeAssert(i64 0, i8* @"reflect/types.typeid:named:main.foo", i8* undef, i8* null)
   store i1 %typecode2, i1* @main.v2
   ret void
 }

main.go

@@ -644,7 +644,7 @@ func Debug(debugger, pkgName string, ocdOutput bool, options *compileopts.Option
 	case "qemu-user":
 		port = ":1234"
 		// Run in an emulator.
-		args := append([]string{"-g", "1234"}, emulator[1:]...)
+		args := append(emulator[1:], "-g", "1234")
 		daemon = executeCommand(config.Options, emulator[0], args...)
 		daemon.Stdout = os.Stdout
 		daemon.Stderr = os.Stderr
@@ -1357,7 +1357,6 @@ func main() {
 	command := os.Args[1]
 
 	opt := flag.String("opt", "z", "optimization level: 0, 1, 2, s, z")
-	lto := flag.String("lto", "legacy", "LTO mode: legacy or thin")
 	gc := flag.String("gc", "", "garbage collector to use (none, leaking, conservative)")
 	panicStrategy := flag.String("panic", "print", "panic strategy (print, trap)")
 	scheduler := flag.String("scheduler", "", "which scheduler to use (none, tasks, asyncify)")
@@ -1460,7 +1459,6 @@ func main() {
 		Target:          *target,
 		StackSize:       stackSize,
 		Opt:             *opt,
-		LTO:             *lto,
 		GC:              *gc,
 		PanicStrategy:   *panicStrategy,
 		Scheduler:       *scheduler,

main_test.go

@@ -105,13 +105,6 @@ func TestBuild(t *testing.T) {
 			runTestWithConfig("print.go", t, opts, nil, nil)
 		})
 
-		t.Run("lto=thin", func(t *testing.T) {
-			t.Parallel()
-			opts := optionsFromTarget("", sema)
-			opts.LTO = "thin"
-			runTestWithConfig("init.go", t, opts, nil, nil)
-		})
-
 		t.Run("ldflags", func(t *testing.T) {
 			t.Parallel()
 			opts := optionsFromTarget("", sema)
@@ -187,8 +180,7 @@ 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 run correctly, probably because of the
-				// limited amount of memory.
+				// Reflect tests do not work due to type code issues.
 				continue
 
 			case "gc.go":
@@ -196,16 +188,20 @@ func runPlatTests(options compileopts.Options, tests []string, t *testing.T) {
 				continue
 
 			case "json.go", "stdlib.go", "testing.go":
-				// Too big for AVR. Doesn't fit in flash/RAM.
+				// Breaks interp.
 				continue
 
 			case "math.go":
-				// Needs newer picolibc version (for sqrt).
+				// Stuck somewhere, not sure what's happening.
 				continue
 
 			case "cgo/":
-				// CGo function pointers don't work on AVR (needs LLVM 16 and
-				// some compiler changes).
+				// 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
 				continue
 
 			default:

src/examples/rtcinterrupt/rtcinterrupt.go

@@ -1,35 +0,0 @@
-//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,10 +2,7 @@
 
 package task
 
-import (
-	"runtime/interrupt"
-	"unsafe"
-)
+import "unsafe"
 
 //go:linkname runtimePanic runtime.runtimePanic
 func runtimePanic(str string)
@@ -48,9 +45,6 @@ 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,6 +4,7 @@ _tinygo_startTask:
 #else
 .section .text.tinygo_startTask
 .global  tinygo_startTask
+.type    tinygo_startTask, %function
 tinygo_startTask:
 #endif
     .cfi_startproc
@@ -34,6 +35,7 @@ tinygo_startTask:
 #endif
     .cfi_endproc
 #ifndef __MACH__
+.size tinygo_startTask, .-tinygo_startTask
 #endif
 
 
@@ -42,6 +44,7 @@ tinygo_startTask:
 _tinygo_swapTask:
 #else
 .global tinygo_swapTask
+.type tinygo_swapTask, %function
 tinygo_swapTask:
 #endif
     // This function gets the following parameters:
@@ -49,16 +52,12 @@ tinygo_swapTask:
     // x1 = oldStack *uintptr
 
     // Save all callee-saved registers:
-    stp     x19, x20, [sp, #-160]!
+    stp     x19, x20, [sp, #-96]!
     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
@@ -68,14 +67,10 @@ 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], #160
+    ldp     x19, x20, [sp], #96
     ret

src/internal/task/task_stack_arm64.go

@@ -1,4 +1,4 @@
-//go:build scheduler.tasks && arm64
+//go:build scheduler.tasks && arm64 && !windows
 
 package task
 
@@ -21,16 +21,8 @@ type calleeSavedRegs struct {
 	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
+	pc uintptr // aka x30 aka LR
 }
 
 // archInit runs architecture-specific setup for the goroutine startup.

src/internal/task/task_stack_arm64_windows.S

@@ -0,0 +1,65 @@
+.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

@@ -0,0 +1,72 @@
+//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/machine/board_lorae5.go

@@ -56,18 +56,6 @@ var (
 	}
 	DefaultUART = UART0
 
-	// 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,
-	}
-
 	// I2C Busses
 	I2C1 = &I2C{
 		Bus:             stm32.I2C1,
@@ -84,5 +72,4 @@ 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 = D0
+	A0 = D1
 	A1 = D1
 	A2 = D2
 	A3 = D3

src/machine/board_xiao-rp2040.go

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

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

src/machine/machine_rp2040_i2c.go

@@ -57,8 +57,6 @@ 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
@@ -92,7 +90,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 && config.SDA == 0 {
+	if config.SCL == 0 {
 		// If config pins are zero valued or clock pin is invalid then we set default values.
 		switch i2c.Bus {
 		case rp.I2C0:
@@ -103,23 +101,6 @@ 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_rtc.go

@@ -1,240 +0,0 @@
-//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

@@ -40,9 +40,6 @@ 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 {
@@ -165,7 +162,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 && config.SDO == 0 && config.SDI == 0 {
+	if config.SCK == 0 {
 		// set default pins if config zero valued or invalid clock pin supplied.
 		switch spi.Bus {
 		case rp.SPI0:
@@ -178,27 +175,6 @@ func (spi SPI) Configure(config SPIConfig) error {
 			config.SDI = SPI1_SDI_PIN
 		}
 	}
-	var okSDI, okSDO, okSCK bool
-	switch spi.Bus {
-	case rp.SPI0:
-		okSDI = config.SDI == 0 || config.SDI == 4 || config.SDI == 16
-		okSDO = config.SDO == 3 || config.SDO == 7 || config.SDO == 19
-		okSCK = config.SCK == 2 || config.SCK == 6 || config.SCK == 18
-	case rp.SPI1:
-		okSDI = config.SDI == 8 || config.SDI == 12 || 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.DataBits < 4 || config.DataBits > 16 {
 		config.DataBits = 8
 	}

src/machine/machine_rp2040_usb.go

@@ -127,10 +127,10 @@ func handleUSBIRQ(intr interrupt.Interrupt) {
 	// Bus is reset
 	if (status & rp.USBCTRL_REGS_INTS_BUS_RESET) > 0 {
 		rp.USBCTRL_REGS.SIE_STATUS.Set(rp.USBCTRL_REGS_SIE_STATUS_BUS_RESET)
-		fixRP2040UsbDeviceEnumeration()
-
 		rp.USBCTRL_REGS.ADDR_ENDP.Set(0)
+
 		initEndpoint(0, usb.ENDPOINT_TYPE_CONTROL)
+		fixRP2040UsbDeviceEnumeration()
 	}
 }
 

src/machine/usb/descriptor.go

@@ -67,7 +67,7 @@ var DescriptorCDCHID = Descriptor{
 		0x07, 0x05, 0x02, 0x02, 0x40, 0x00, 0x00,
 		0x07, 0x05, 0x83, 0x02, 0x40, 0x00, 0x00,
 		0x09, 0x04, 0x02, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00,
-		0x09, 0x21, 0x01, 0x01, 0x00, 0x01, 0x22, 0x7E, 0x00,
+		0x09, 0x21, 0x01, 0x01, 0x00, 0x01, 0x22, 0x65, 0x00,
 		0x07, 0x05, 0x84, 0x03, 0x40, 0x00, 0x01,
 	},
 	HID: map[uint16][]byte{
@@ -80,19 +80,6 @@ var DescriptorCDCHID = Descriptor{
 			0x03, 0x15, 0x00, 0x25, 0x01, 0x95, 0x03, 0x75, 0x01, 0x81, 0x02, 0x95, 0x01, 0x75, 0x05, 0x81,
 			0x03, 0x05, 0x01, 0x09, 0x30, 0x09, 0x31, 0x09, 0x38, 0x15, 0x81, 0x25, 0x7f, 0x75, 0x08, 0x95,
 			0x03, 0x81, 0x06, 0xc0, 0xc0,
-
-			0x05, 0x0C, //       Usage Page (Consumer)
-			0x09, 0x01, //       Usage (Consumer Control)
-			0xA1, 0x01, //       Collection (Application)
-			0x85, 0x03, //         Report ID (3)
-			0x15, 0x00, //         Logical Minimum (0)
-			0x26, 0xFF, 0x1F, //   Logical Maximum (8191)
-			0x19, 0x00, //         Usage Minimum (Unassigned)
-			0x2A, 0xFF, 0x1F, //   Usage Maximum (0x1FFF)
-			0x75, 0x10, //         Report Size (16)
-			0x95, 0x01, //         Report Count (1)
-			0x81, 0x00, //         Input (Data,Array,Abs,No Wrap,Linear,Preferred State,No Null Position)
-			0xC0, //             End       Collection
 		},
 	},
 }

src/machine/usb/hid/keyboard/keyboard.go

@@ -238,26 +238,16 @@ func (kb *keyboard) sendKey(consumer bool, b []byte) bool {
 
 func (kb *keyboard) keyboardSendKeys(consumer bool) bool {
 	var b [9]byte
-
-	if !consumer {
-		b[0] = 0x02 // REPORT_ID
-		b[1] = kb.mod
-		b[2] = 0x02
-		b[3] = kb.key[0]
-		b[4] = kb.key[1]
-		b[5] = kb.key[2]
-		b[6] = kb.key[3]
-		b[7] = kb.key[4]
-		b[8] = kb.key[5]
-		return kb.sendKey(consumer, b[:])
-
-	} else {
-		b[0] = 0x03 // REPORT_ID
-		b[1] = uint8(kb.con[0])
-		b[2] = uint8((kb.con[0] & 0x0300) >> 8)
-
-		return kb.sendKey(consumer, b[:3])
-	}
+	b[0] = 0x02
+	b[1] = kb.mod
+	b[2] = 0x02
+	b[3] = kb.key[0]
+	b[4] = kb.key[1]
+	b[5] = kb.key[2]
+	b[6] = kb.key[3]
+	b[7] = kb.key[4]
+	b[8] = kb.key[5]
+	return kb.sendKey(consumer, b[:])
 }
 
 // Down transmits a key-down event for the given Keycode.

src/machine/usb/hid/keyboard/keycode.go

@@ -77,7 +77,6 @@ const (
 	KeyModifierRightAlt   Keycode = 0x40 | 0xE000
 	KeyModifierRightGUI   Keycode = 0x80 | 0xE000
 
-	// KeySystemXXX is not supported now
 	KeySystemPowerDown Keycode = 0x81 | 0xE200
 	KeySystemSleep     Keycode = 0x82 | 0xE200
 	KeySystemWakeUp    Keycode = 0x83 | 0xE200

src/reflect/deepequal.go

@@ -15,7 +15,7 @@ import "unsafe"
 type visit struct {
 	a1  unsafe.Pointer
 	a2  unsafe.Pointer
-	typ *rawType
+	typ rawType
 }
 
 // Tests for deep equality using reflected types. The map argument tracks

src/reflect/sidetables.go

@@ -0,0 +1,61 @@
+package reflect
+
+import (
+	"unsafe"
+)
+
+// This stores a varint for each named type. Named types are identified by their
+// name instead of by their type. The named types stored in this struct are
+// non-basic types: pointer, struct, and channel.
+//
+//go:extern reflect.namedNonBasicTypesSidetable
+var namedNonBasicTypesSidetable uintptr
+
+//go:extern reflect.structTypesSidetable
+var structTypesSidetable byte
+
+//go:extern reflect.structNamesSidetable
+var structNamesSidetable byte
+
+//go:extern reflect.arrayTypesSidetable
+var arrayTypesSidetable byte
+
+// readStringSidetable reads a string from the given table (like
+// structNamesSidetable) and returns this string. No heap allocation is
+// necessary because it makes the string point directly to the raw bytes of the
+// table.
+func readStringSidetable(table unsafe.Pointer, index uintptr) string {
+	nameLen, namePtr := readVarint(unsafe.Pointer(uintptr(table) + index))
+	return *(*string)(unsafe.Pointer(&stringHeader{
+		data: namePtr,
+		len:  nameLen,
+	}))
+}
+
+// readVarint decodes a varint as used in the encoding/binary package.
+// It has an input pointer and returns the read varint and the pointer
+// incremented to the next field in the data structure, just after the varint.
+//
+// Details:
+// https://github.com/golang/go/blob/e37a1b1c/src/encoding/binary/varint.go#L7-L25
+func readVarint(buf unsafe.Pointer) (uintptr, unsafe.Pointer) {
+	var n uintptr
+	shift := uintptr(0)
+	for {
+		// Read the next byte in the buffer.
+		c := *(*byte)(buf)
+
+		// Decode the bits from this byte and add them to the output number.
+		n |= uintptr(c&0x7f) << shift
+		shift += 7
+
+		// Increment the buf pointer (pointer arithmetic!).
+		buf = unsafe.Pointer(uintptr(buf) + 1)
+
+		// Check whether this is the last byte of this varint. The upper bit
+		// (msb) indicates whether any bytes follow.
+		if c>>7 == 0 {
+			return n, buf
+		}
+	}
+}

src/reflect/type.go

@@ -2,72 +2,36 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// Type information of an interface is stored as a pointer to a global in the
-// interface type (runtime._interface). This is called a type struct.
-// It always starts with a byte that contains both the type kind and a few
-// flags. In most cases it also contains a pointer to another type struct
-// (ptrTo), that is the pointer type of the current type (for example, type int
-// also has a pointer to the type *int). The exception is pointer types, to
-// avoid infinite recursion.
-//
-// The layouts specifically look like this:
-// - basic types (Bool..UnsafePointer):
-//     meta         uint8 // actually: kind + flags
-//     ptrTo        *typeStruct
-// - named types (see elemType):
-//     meta         uint8
-//     ptrTo        *typeStruct
-//     underlying   *typeStruct // the underlying, non-named type
-// - channels and slices (see elemType):
-//     meta          uint8
-//     ptrTo        *typeStruct
-//     elementType  *typeStruct // the type that you get with .Elem()
-// - pointer types (see ptrType, this doesn't include chan, map, etc):
-//     meta         uint8
-//     elementType  *typeStruct
-// - array types (see arrayType)
-//     meta         uint8
-//     ptrTo        *typeStruct
-//     elem         *typeStruct // element type of the array
-//     arrayLen     uintptr     // length of the array (this is part of the type)
-// - map types (this is still missing the key and element types)
-//     meta         uint8
-//     ptrTo        *typeStruct
-// - struct types (see structType):
-//     meta         uint8
-//     numField     uint16
-//     ptrTo        *typeStruct
-//     fields       [...]structField // the remaining fields are all of type structField
-// - interface types (this is missing the interface methods):
-//     meta         uint8
-//     ptrTo        *typeStruct
-// - signature types (this is missing input and output parameters):
-//     meta         uint8
-//     ptrTo        *typeStruct
-//
-// The type struct is essentially a union of all the above types. Which it is,
-// can be determined by looking at the meta byte.
-
 package reflect
 
 import (
 	"unsafe"
 )
 
-// Flags stored in the first byte of the struct field byte array. Must be kept
-// up to date with compiler/interface.go.
-const (
-	structFieldFlagAnonymous = 1 << iota
-	structFieldFlagHasTag
-	structFieldFlagIsExported
-)
+// The compiler uses a compact encoding to store type information. Unlike the
+// main Go compiler, most of the types are stored directly in the type code.
+//
+// Type code bit allocation:
+// xxxxx0: basic types, where xxxxx is the basic type number (never 0).
+//         The higher bits indicate the named type, if any.
+//  nxxx1: complex types, where n indicates whether this is a named type (named
+//         if set) and xxx contains the type kind number:
+//             0 (0001): Chan
+//             1 (0011): Interface
+//             2 (0101): Pointer
+//             3 (0111): Slice
+//             4 (1001): Array
+//             5 (1011): Func
+//             6 (1101): Map
+//             7 (1111): Struct
+//         The higher bits are either the contents of the type depending on the
+//         type (if n is clear) or indicate the number of the named type (if n
+//         is set).
 
-type Kind uint8
+type Kind uintptr
 
 // Copied from reflect/type.go
 // https://golang.org/src/reflect/type.go?s=8302:8316#L217
-// These constants must match basicTypes and the typeKind* constants in
-// compiler/interface.go
 const (
 	Invalid Kind = iota
 	Bool
@@ -160,6 +124,11 @@ func (k Kind) String() string {
 	}
 }
 
+// basicType returns a new Type for this kind if Kind is a basic type.
+func (k Kind) basicType() rawType {
+	return rawType(k << 1)
+}
+
 // Copied from reflect/type.go
 // https://go.dev/src/reflect/type.go?#L348
 
@@ -377,64 +346,8 @@ type Type interface {
 	Out(i int) Type
 }
 
-// Constants for the 'meta' byte.
-const (
-	kindMask  = 31 // mask to apply to the meta byte to get the Kind value
-	flagNamed = 32 // flag that is set if this is a named type
-)
-
-// The base type struct. All type structs start with this.
-type rawType struct {
-	meta uint8 // metadata byte, contains kind and flags (see contants above)
-}
-
-// All types that have an element type: named, chan, slice, array, map (but not
-// pointer because it doesn't have ptrTo).
-type elemType struct {
-	rawType
-	ptrTo *rawType
-	elem  *rawType
-}
-
-type ptrType struct {
-	rawType
-	elem *rawType
-}
-
-type arrayType struct {
-	rawType
-	ptrTo    *rawType
-	elem     *rawType
-	arrayLen uintptr
-}
-
-// Type for struct types. The numField value is intentionally put before ptrTo
-// for better struct packing on 32-bit and 64-bit architectures. On these
-// architectures, the ptrTo field still has the same offset as in all the other
-// type structs.
-// The fields array isn't necessarily 1 structField long, instead it is as long
-// as numFields. The array is given a length of 1 to satisfy the Go type
-// checker.
-type structType struct {
-	rawType
-	numField uint16
-	ptrTo    *rawType
-	fields   [1]structField // the remaining fields are all of type structField
-}
-
-type structField struct {
-	fieldType *rawType
-	data      unsafe.Pointer // various bits of information, packed in a byte array
-}
-
-// Equivalent to (go/types.Type).Underlying(): if this is a named type return
-// the underlying type, else just return the type itself.
-func (t *rawType) underlying() *rawType {
-	if t.meta&flagNamed != 0 {
-		return (*elemType)(unsafe.Pointer(t)).elem
-	}
-	return t
-}
+// The typecode as used in an interface{}.
+type rawType uintptr
 
 func TypeOf(i interface{}) Type {
 	return ValueOf(i).typecode
@@ -443,45 +356,70 @@ func TypeOf(i interface{}) Type {
 func PtrTo(t Type) Type { return PointerTo(t) }
 
 func PointerTo(t Type) Type {
-	switch t.Kind() {
-	case Pointer:
+	if t.Kind() == Pointer {
 		panic("reflect: cannot make **T type")
-	case Struct:
-		return (*structType)(unsafe.Pointer(t.(*rawType))).ptrTo
-	default:
-		return (*elemType)(unsafe.Pointer(t.(*rawType))).ptrTo
 	}
+	ptrType := t.(rawType)<<5 | 5 // 0b0101 == 5
+	if ptrType>>5 != t {
+		panic("reflect: PointerTo type does not fit")
+	}
+	return ptrType
 }
 
-func (t *rawType) String() string {
+func (t rawType) String() string {
 	return "T"
 }
 
-func (t *rawType) Kind() Kind {
-	return Kind(t.meta & kindMask)
+func (t rawType) Kind() Kind {
+	if t%2 == 0 {
+		// basic type
+		return Kind((t >> 1) % 32)
+	} else {
+		return Kind(t>>1)%8 + 19
+	}
 }
 
 // Elem returns the element type for channel, slice and array types, the
 // pointed-to value for pointer types, and the key type for map types.
-func (t *rawType) Elem() Type {
+func (t rawType) Elem() Type {
 	return t.elem()
 }
 
-func (t *rawType) elem() *rawType {
-	underlying := t.underlying()
-	switch underlying.Kind() {
-	case Pointer:
-		return (*ptrType)(unsafe.Pointer(underlying)).elem
-	case Chan, Slice, Array:
-		return (*elemType)(unsafe.Pointer(underlying)).elem
+func (t rawType) elem() rawType {
+	switch t.Kind() {
+	case Chan, Pointer, Slice:
+		return t.stripPrefix()
+	case Array:
+		index := t.stripPrefix()
+		elem, _ := readVarint(unsafe.Pointer(uintptr(unsafe.Pointer(&arrayTypesSidetable)) + uintptr(index)))
+		return rawType(elem)
 	default: // not implemented: Map
 		panic("unimplemented: (reflect.Type).Elem()")
 	}
 }
 
+// stripPrefix removes the "prefix" (the low 5 bits of the type code) from
+// the type code. If this is a named type, it will resolve the underlying type
+// (which is the data for this named type). If it is not, the lower bits are
+// simply shifted off.
+//
+// The behavior is only defined for non-basic types.
+func (t rawType) stripPrefix() rawType {
+	// Look at the 'n' bit in the type code (see the top of this file) to see
+	// whether this is a named type.
+	if (t>>4)%2 != 0 {
+		// This is a named type. The data is stored in a sidetable.
+		namedTypeNum := t >> 5
+		n := *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&namedNonBasicTypesSidetable)) + uintptr(namedTypeNum)*unsafe.Sizeof(uintptr(0))))
+		return rawType(n)
+	}
+	// Not a named type, so the value is stored directly in the type code.
+	return t >> 5
+}
+
 // Field returns the type of the i'th field of this struct type. It panics if t
 // is not a struct type.
-func (t *rawType) Field(i int) StructField {
+func (t rawType) Field(i int) StructField {
 	field := t.rawField(i)
 	return StructField{
 		Name:      field.Name,
@@ -497,87 +435,82 @@ func (t *rawType) Field(i int) StructField {
 // Type member to an interface.
 //
 // For internal use only.
-func (t *rawType) rawField(n int) rawStructField {
+func (t rawType) rawField(i int) rawStructField {
 	if t.Kind() != Struct {
 		panic(&TypeError{"Field"})
 	}
-	descriptor := (*structType)(unsafe.Pointer(t.underlying()))
-	if uint(n) >= uint(descriptor.numField) {
+	structIdentifier := t.stripPrefix()
+
+	numField, p := readVarint(unsafe.Pointer(uintptr(unsafe.Pointer(&structTypesSidetable)) + uintptr(structIdentifier)))
+	if uint(i) >= uint(numField) {
 		panic("reflect: field index out of range")
 	}
 
-	// Iterate over all the fields to calculate the offset.
-	// This offset could have been stored directly in the array (to make the
-	// lookup faster), but by calculating it on-the-fly a bit of storage can be
-	// saved.
-	field := &descriptor.fields[0]
-	var offset uintptr = 0
-	for i := 0; i < n; i++ {
-		offset += field.fieldType.Size()
+	// Iterate over every field in the struct and update the StructField each
+	// time, until the target field has been reached. This is very much not
+	// efficient, but it is easy to implement.
+	// Adding a jump table at the start to jump to the field directly would
+	// make this much faster, but that would also impact code size.
+	field := rawStructField{}
+	offset := uintptr(0)
+	for fieldNum := 0; fieldNum <= i; fieldNum++ {
+		// Read some flags of this field, like whether the field is an
+		// embedded field.
+		flagsByte := *(*uint8)(p)
+		p = unsafe.Pointer(uintptr(p) + 1)
 
-		// Increment pointer to the next field.
-		field = (*structField)(unsafe.Add(unsafe.Pointer(field), unsafe.Sizeof(structField{})))
+		// Read the type of this struct field.
+		var fieldTypeVal uintptr
+		fieldTypeVal, p = readVarint(p)
+		fieldType := rawType(fieldTypeVal)
+		field.Type = fieldType
 
-		// Align the offset for the next field.
-		offset = align(offset, uintptr(field.fieldType.Align()))
+		// Move Offset forward to align it to this field's alignment.
+		// Assume alignment is a power of two.
+		offset = align(offset, uintptr(fieldType.Align()))
+		field.Offset = offset
+		offset += fieldType.Size() // starting (unaligned) offset for next field
+
+		// Read the field name.
+		var nameNum uintptr
+		nameNum, p = readVarint(p)
+		field.Name = readStringSidetable(unsafe.Pointer(&structNamesSidetable), nameNum)
+
+		// The first bit in the flagsByte indicates whether this is an embedded
+		// field.
+		field.Anonymous = flagsByte&1 != 0
+
+		// The second bit indicates whether there is a tag.
+		if flagsByte&2 != 0 {
+			// There is a tag.
+			var tagNum uintptr
+			tagNum, p = readVarint(p)
+			field.Tag = StructTag(readStringSidetable(unsafe.Pointer(&structNamesSidetable), tagNum))
+		} else {
+			// There is no tag.
+			field.Tag = ""
+		}
+
+		// The third bit indicates whether this field is exported.
+		if flagsByte&4 != 0 {
+			// This field is exported.
+			field.PkgPath = ""
+		} else {
+			// This field is unexported.
+			// TODO: list the real package path here. Storing it should not
+			// significantly impact binary size as there is only a limited
+			// number of packages in any program.
+			field.PkgPath = "<unimplemented>"
+		}
 	}
 
-	data := field.data
-
-	// Read some flags of this field, like whether the field is an embedded
-	// field. See structFieldFlagAnonymous and similar flags.
-	flagsByte := *(*byte)(data)
-	data = unsafe.Add(data, 1)
-
-	// Read the field name.
-	nameStart := data
-	var nameLen uintptr
-	for *(*byte)(data) != 0 {
-		nameLen++
-		data = unsafe.Add(data, 1) // C: data++
-	}
-	name := *(*string)(unsafe.Pointer(&stringHeader{
-		data: nameStart,
-		len:  nameLen,
-	}))
-
-	// Read the field tag, if there is one.
-	var tag string
-	if flagsByte&structFieldFlagHasTag != 0 {
-		data = unsafe.Add(data, 1) // C: data+1
-		tagLen := uintptr(*(*byte)(data))
-		data = unsafe.Add(data, 1) // C: data+1
-		tag = *(*string)(unsafe.Pointer(&stringHeader{
-			data: data,
-			len:  tagLen,
-		}))
-	}
-
-	// Set the PkgPath to some (arbitrary) value if the package path is not
-	// exported.
-	pkgPath := ""
-	if flagsByte&structFieldFlagIsExported == 0 {
-		// This field is unexported.
-		// TODO: list the real package path here. Storing it should not
-		// significantly impact binary size as there is only a limited
-		// number of packages in any program.
-		pkgPath = "<unimplemented>"
-	}
-
-	return rawStructField{
-		Name:      name,
-		PkgPath:   pkgPath,
-		Type:      field.fieldType,
-		Tag:       StructTag(tag),
-		Anonymous: flagsByte&structFieldFlagAnonymous != 0,
-		Offset:    offset,
-	}
+	return field
 }
 
 // Bits returns the number of bits that this type uses. It is only valid for
 // arithmetic types (integers, floats, and complex numbers). For other types, it
 // will panic.
-func (t *rawType) Bits() int {
+func (t rawType) Bits() int {
 	kind := t.Kind()
 	if kind >= Int && kind <= Complex128 {
 		return int(t.Size()) * 8
@@ -587,26 +520,34 @@ func (t *rawType) Bits() int {
 
 // Len returns the number of elements in this array. It panics of the type kind
 // is not Array.
-func (t *rawType) Len() int {
+func (t rawType) Len() int {
 	if t.Kind() != Array {
 		panic(TypeError{"Len"})
 	}
 
-	return int((*arrayType)(unsafe.Pointer(t.underlying())).arrayLen)
+	// skip past the element type
+	arrayIdentifier := t.stripPrefix()
+	_, p := readVarint(unsafe.Pointer(uintptr(unsafe.Pointer(&arrayTypesSidetable)) + uintptr(arrayIdentifier)))
+
+	// Read the array length.
+	arrayLen, _ := readVarint(p)
+	return int(arrayLen)
 }
 
 // NumField returns the number of fields of a struct type. It panics for other
 // type kinds.
-func (t *rawType) NumField() int {
+func (t rawType) NumField() int {
 	if t.Kind() != Struct {
 		panic(&TypeError{"NumField"})
 	}
-	return int((*structType)(unsafe.Pointer(t.underlying())).numField)
+	structIdentifier := t.stripPrefix()
+	n, _ := readVarint(unsafe.Pointer(uintptr(unsafe.Pointer(&structTypesSidetable)) + uintptr(structIdentifier)))
+	return int(n)
 }
 
 // Size returns the size in bytes of a given type. It is similar to
 // unsafe.Sizeof.
-func (t *rawType) Size() uintptr {
+func (t rawType) Size() uintptr {
 	switch t.Kind() {
 	case Bool, Int8, Uint8:
 		return 1
@@ -655,7 +596,7 @@ func (t *rawType) Size() uintptr {
 
 // Align returns the alignment of this type. It is similar to calling
 // unsafe.Alignof.
-func (t *rawType) Align() int {
+func (t rawType) Align() int {
 	switch t.Kind() {
 	case Bool, Int8, Uint8:
 		return int(unsafe.Alignof(int8(0)))
@@ -707,14 +648,14 @@ func (t *rawType) Align() int {
 
 // FieldAlign returns the alignment if this type is used in a struct field. It
 // is currently an alias for Align() but this might change in the future.
-func (t *rawType) FieldAlign() int {
+func (t rawType) FieldAlign() int {
 	return t.Align()
 }
 
 // AssignableTo returns whether a value of type t can be assigned to a variable
 // of type u.
-func (t *rawType) AssignableTo(u Type) bool {
-	if t == u.(*rawType) {
+func (t rawType) AssignableTo(u Type) bool {
+	if t == u.(rawType) {
 		return true
 	}
 	if u.Kind() == Interface {
@@ -723,7 +664,7 @@ func (t *rawType) AssignableTo(u Type) bool {
 	return false
 }
 
-func (t *rawType) Implements(u Type) bool {
+func (t rawType) Implements(u Type) bool {
 	if u.Kind() != Interface {
 		panic("reflect: non-interface type passed to Type.Implements")
 	}
@@ -731,7 +672,7 @@ func (t *rawType) Implements(u Type) bool {
 }
 
 // Comparable returns whether values of this type can be compared to each other.
-func (t *rawType) Comparable() bool {
+func (t rawType) Comparable() bool {
 	switch t.Kind() {
 	case Bool, Int, Int8, Int16, Int32, Int64, Uint, Uint8, Uint16, Uint32, Uint64, Uintptr:
 		return true
@@ -772,31 +713,31 @@ func (t rawType) ChanDir() ChanDir {
 	panic("unimplemented: (reflect.Type).ChanDir()")
 }
 
-func (t *rawType) ConvertibleTo(u Type) bool {
+func (t rawType) ConvertibleTo(u Type) bool {
 	panic("unimplemented: (reflect.Type).ConvertibleTo()")
 }
 
-func (t *rawType) IsVariadic() bool {
+func (t rawType) IsVariadic() bool {
 	panic("unimplemented: (reflect.Type).IsVariadic()")
 }
 
-func (t *rawType) NumIn() int {
+func (t rawType) NumIn() int {
 	panic("unimplemented: (reflect.Type).NumIn()")
 }
 
-func (t *rawType) NumOut() int {
+func (t rawType) NumOut() int {
 	panic("unimplemented: (reflect.Type).NumOut()")
 }
 
-func (t *rawType) NumMethod() int {
+func (t rawType) NumMethod() int {
 	panic("unimplemented: (reflect.Type).NumMethod()")
 }
 
-func (t *rawType) Name() string {
+func (t rawType) Name() string {
 	panic("unimplemented: (reflect.Type).Name()")
 }
 
-func (t *rawType) Key() Type {
+func (t rawType) Key() Type {
 	panic("unimplemented: (reflect.Type).Key()")
 }
 
@@ -851,7 +792,7 @@ func (f StructField) IsExported() bool {
 type rawStructField struct {
 	Name      string
 	PkgPath   string
-	Type      *rawType
+	Type      rawType
 	Tag       StructTag
 	Anonymous bool
 	Offset    uintptr

src/reflect/value.go

@@ -17,7 +17,7 @@ const (
 )
 
 type Value struct {
-	typecode *rawType
+	typecode rawType
 	value    unsafe.Pointer
 	flags    valueFlags
 }
@@ -44,15 +44,15 @@ func Indirect(v Value) Value {
 }
 
 //go:linkname composeInterface runtime.composeInterface
-func composeInterface(unsafe.Pointer, unsafe.Pointer) interface{}
+func composeInterface(rawType, unsafe.Pointer) interface{}
 
 //go:linkname decomposeInterface runtime.decomposeInterface
-func decomposeInterface(i interface{}) (unsafe.Pointer, unsafe.Pointer)
+func decomposeInterface(i interface{}) (rawType, unsafe.Pointer)
 
 func ValueOf(i interface{}) Value {
 	typecode, value := decomposeInterface(i)
 	return Value{
-		typecode: (*rawType)(typecode),
+		typecode: typecode,
 		value:    value,
 		flags:    valueFlagExported,
 	}
@@ -85,7 +85,7 @@ func valueInterfaceUnsafe(v Value) interface{} {
 		}
 		v.value = unsafe.Pointer(value)
 	}
-	return composeInterface(unsafe.Pointer(v.typecode), v.value)
+	return composeInterface(v.typecode, v.value)
 }
 
 func (v Value) Type() Type {
@@ -136,7 +136,7 @@ func (v Value) IsZero() bool {
 //
 // RawType returns the raw, underlying type code. It is used in the runtime
 // package and needs to be exported for the runtime package to access it.
-func (v Value) RawType() *rawType {
+func (v Value) RawType() rawType {
 	return v.typecode
 }
 
@@ -205,7 +205,7 @@ func (v Value) pointer() unsafe.Pointer {
 }
 
 func (v Value) IsValid() bool {
-	return v.typecode != nil
+	return v.typecode != 0
 }
 
 func (v Value) CanInterface() bool {
@@ -453,7 +453,7 @@ func (v Value) Elem() Value {
 	case Interface:
 		typecode, value := decomposeInterface(*(*interface{})(v.value))
 		return Value{
-			typecode: (*rawType)(typecode),
+			typecode: typecode,
 			value:    value,
 			flags:    v.flags &^ valueFlagIndirect,
 		}
@@ -523,8 +523,6 @@ func (v Value) Field(i int) Value {
 	}
 }
 
-var uint8Type = TypeOf(uint8(0)).(*rawType)
-
 func (v Value) Index(i int) Value {
 	switch v.Kind() {
 	case Slice:
@@ -552,7 +550,7 @@ func (v Value) Index(i int) Value {
 			panic("reflect: string index out of range")
 		}
 		return Value{
-			typecode: uint8Type,
+			typecode: Uint8.basicType(),
 			value:    unsafe.Pointer(uintptr(*(*uint8)(unsafe.Pointer(uintptr(s.data) + uintptr(i))))),
 			flags:    v.flags & valueFlagExported,
 		}
@@ -805,7 +803,7 @@ func Zero(typ Type) Value {
 // new value of the given type.
 func New(typ Type) Value {
 	return Value{
-		typecode: PtrTo(typ).(*rawType),
+		typecode: PtrTo(typ).(rawType),
 		value:    alloc(typ.Size(), nil),
 		flags:    valueFlagExported,
 	}

src/runtime/asm_arm64.S

@@ -4,6 +4,7 @@ _tinygo_scanCurrentStack:
 #else
 .section .text.tinygo_scanCurrentStack
 .global tinygo_scanCurrentStack
+.type tinygo_scanCurrentStack, %function
 tinygo_scanCurrentStack:
 #endif
     // Sources:
@@ -11,16 +12,12 @@ tinygo_scanCurrentStack:
     //   * https://godbolt.org/z/qrvrEh
 
     // Save callee-saved registers.
-    stp     x29, x30, [sp, #-160]!
+    stp     x29, x30, [sp, #-96]!
     stp     x28, x27, [sp, #16]
     stp     x26, x25, [sp, #32]
     stp     x24, x23, [sp, #48]
     stp     x22, x21, [sp, #64]
     stp     x20, x19, [sp, #80]
-    stp     d8,  d9,  [sp, #96]
-    stp     d10, d11, [sp, #112]
-    stp     d12, d13, [sp, #128]
-    stp     d14, d15, [sp, #144]
 
     // Scan the stack.
     mov     x0, sp
@@ -31,7 +28,7 @@ tinygo_scanCurrentStack:
 #endif
 
     // Restore stack state and return.
-    ldp     x29, x30, [sp], #160
+    ldp     x29, x30, [sp], #96
     ret
 
 
@@ -41,6 +38,7 @@ _tinygo_longjmp:
 #else
 .section .text.tinygo_longjmp
 .global tinygo_longjmp
+.type tinygo_longjmp, %function
 tinygo_longjmp:
 #endif
     // Note: the code we jump to assumes x0 is set to a non-zero value if we

src/runtime/asm_arm64_windows.S

@@ -0,0 +1,36 @@
+.section .text.tinygo_scanCurrentStack,"ax"
+.global tinygo_scanCurrentStack
+tinygo_scanCurrentStack:
+    // Sources:
+    //   * https://learn.microsoft.com/en-us/cpp/build/arm64-windows-abi-conventions?view=msvc-170
+    //   * https://godbolt.org/z/foc1xncvb
+
+    // Save callee-saved registers.
+    stp     x29, x30, [sp, #-160]!
+    stp     x28, x27, [sp, #16]
+    stp     x26, x25, [sp, #32]
+    stp     x24, x23, [sp, #48]
+    stp     x22, x21, [sp, #64]
+    stp     x20, x19, [sp, #80]
+    stp     d8,  d9,  [sp, #96]
+    stp     d10, d11, [sp, #112]
+    stp     d12, d13, [sp, #128]
+    stp     d14, d15, [sp, #144]
+
+    // Scan the stack.
+    mov     x0, sp
+    bl      tinygo_scanstack
+
+    // Restore stack state and return.
+    ldp     x29, x30, [sp], #160
+    ret
+
+
+.section .text.tinygo_longjmp,"ax"
+.global tinygo_longjmp
+tinygo_longjmp:
+    // Note: the code we jump to assumes x0 is set to a non-zero value if we
+    // jump from here (which is conveniently already the case).
+    ldp x1, x2, [x0] // jumpSP, jumpPC
+    mov sp, x1
+    br  x2

src/runtime/env.go

@@ -1,51 +0,0 @@
-//go:build linux || darwin || windows
-
-package runtime
-
-// Update the C environment if cgo is loaded.
-// Called from Go 1.20 and above.
-//
-//go:linkname syscallSetenv syscall.runtimeSetenv
-func syscallSetenv(key, value string) {
-	keydata := cstring(key)
-	valdata := cstring(value)
-	setenv(&keydata[0], &valdata[0])
-	if key == "GODEBUG" && godebugUpdate != nil {
-		// Starting with Go 1.20, we need to call a callback (set by
-		// internal/godebug) to notify the GODEBUG environment variable has
-		// changed. This is necessary to get archive/zip to pass tests.
-		godebugUpdate(key, value)
-	}
-}
-
-// Update the C environment if cgo is loaded.
-// Called from Go 1.20 and above.
-//
-//go:linkname syscallUnsetenv syscall.runtimeUnsetenv
-func syscallUnsetenv(key string) {
-	keydata := cstring(key)
-	unsetenv(&keydata[0])
-}
-
-// Compatibility with Go 1.19 and below.
-//
-//go:linkname syscall_setenv_c syscall.setenv_c
-func syscall_setenv_c(key string, val string) {
-	syscallSetenv(key, val)
-}
-
-// Compatibility with Go 1.19 and below.
-//
-//go:linkname syscall_unsetenv_c syscall.unsetenv_c
-func syscall_unsetenv_c(key string) {
-	syscallUnsetenv(key)
-}
-
-// cstring converts a Go string to a C string.
-// borrowed from syscall
-func cstring(s string) []byte {
-	data := make([]byte, len(s)+1)
-	copy(data, s)
-	// final byte should be zero from the initial allocation
-	return data
-}

src/runtime/env_unix.go

@@ -2,6 +2,50 @@
 
 package runtime
 
+// Update the C environment if cgo is loaded.
+// Called from Go 1.20 and above.
+//
+//go:linkname syscallSetenv syscall.runtimeSetenv
+func syscallSetenv(key, value string) {
+	keydata := cstring(key)
+	valdata := cstring(value)
+	// ignore any errors
+	libc_setenv(&keydata[0], &valdata[0], 1)
+}
+
+// Update the C environment if cgo is loaded.
+// Called from Go 1.20 and above.
+//
+//go:linkname syscallUnsetenv syscall.runtimeUnsetenv
+func syscallUnsetenv(key string) {
+	keydata := cstring(key)
+	// ignore any errors
+	libc_unsetenv(&keydata[0])
+}
+
+// Compatibility with Go 1.19 and below.
+//
+//go:linkname syscall_setenv_c syscall.setenv_c
+func syscall_setenv_c(key string, val string) {
+	syscallSetenv(key, val)
+}
+
+// Compatibility with Go 1.19 and below.
+//
+//go:linkname syscall_unsetenv_c syscall.unsetenv_c
+func syscall_unsetenv_c(key string) {
+	syscallUnsetenv(key)
+}
+
+// cstring converts a Go string to a C string.
+// borrowed from syscall
+func cstring(s string) []byte {
+	data := make([]byte, len(s)+1)
+	copy(data, s)
+	// final byte should be zero from the initial allocation
+	return data
+}
+
 // int setenv(const char *name, const char *val, int replace);
 //
 //export setenv
@@ -11,13 +55,3 @@ func libc_setenv(name *byte, val *byte, replace int32) int32
 //
 //export unsetenv
 func libc_unsetenv(name *byte) int32
-
-func setenv(key, val *byte) {
-	// ignore any errors
-	libc_setenv(key, val, 1)
-}
-
-func unsetenv(key *byte) {
-	// ignore any errors
-	libc_unsetenv(key)
-}

src/runtime/env_windows.go

@@ -1,23 +0,0 @@
-//go:build windows
-
-package runtime
-
-// Set environment variable in Windows:
-//
-//	BOOL SetEnvironmentVariableA(
-//	    [in]           LPCSTR lpName,
-//	    [in, optional] LPCSTR lpValue
-//	);
-//
-//export SetEnvironmentVariableA
-func _SetEnvironmentVariableA(key, val *byte) bool
-
-func setenv(key, val *byte) {
-	// ignore any errors
-	_SetEnvironmentVariableA(key, val)
-}
-
-func unsetenv(key *byte) {
-	// ignore any errors
-	_SetEnvironmentVariableA(key, nil)
-}

src/runtime/gc_blocks.go

@@ -277,10 +277,6 @@ func alloc(size uintptr, layout unsafe.Pointer) unsafe.Pointer {
 		size += align(unsafe.Sizeof(layout))
 	}
 
-	if interrupt.In() {
-		runtimePanic("alloc in interrupt")
-	}
-
 	gcTotalAlloc += uint64(size)
 	gcMallocs++
 
@@ -691,7 +687,3 @@ func ReadMemStats(m *MemStats) {
 	m.Frees = gcFrees
 	m.Sys = uint64(heapEnd - heapStart)
 }
-
-func SetFinalizer(obj interface{}, finalizer interface{}) {
-	// Unimplemented.
-}

src/runtime/gc_custom.go

@@ -20,7 +20,6 @@ package runtime
 // - func free(ptr unsafe.Pointer)
 // - func markRoots(start, end uintptr)
 // - func GC()
-// - func SetFinalizer(obj interface{}, finalizer interface{})
 // - func ReadMemStats(ms *runtime.MemStats)
 //
 //
@@ -52,9 +51,6 @@ func markRoots(start, end uintptr)
 // GC is called to explicitly run garbage collection.
 func GC()
 
-// SetFinalizer registers a finalizer.
-func SetFinalizer(obj interface{}, finalizer interface{})
-
 // ReadMemStats populates m with memory statistics.
 func ReadMemStats(ms *MemStats)
 

src/runtime/gc_leaking.go

@@ -85,10 +85,6 @@ func GC() {
 	// No-op.
 }
 
-func SetFinalizer(obj interface{}, finalizer interface{}) {
-	// No-op.
-}
-
 func initHeap() {
 	// preinit() may have moved heapStart; reset heapptr
 	heapptr = heapStart

src/runtime/gc_none.go

@@ -26,10 +26,6 @@ func GC() {
 	// Unimplemented.
 }
 
-func SetFinalizer(obj interface{}, finalizer interface{}) {
-	// Unimplemented.
-}
-
 func initHeap() {
 	// Nothing to initialize.
 }

src/runtime/hashmap.go

@@ -506,7 +506,7 @@ func hashmapFloat64Hash(ptr unsafe.Pointer, seed uintptr) uint32 {
 
 func hashmapInterfaceHash(itf interface{}, seed uintptr) uint32 {
 	x := reflect.ValueOf(itf)
-	if x.RawType() == nil {
+	if x.RawType() == 0 {
 		return 0 // nil interface
 	}
 
@@ -563,7 +563,7 @@ func hashmapInterfaceHash(itf interface{}, seed uintptr) uint32 {
 }
 
 func hashmapInterfacePtrHash(iptr unsafe.Pointer, size uintptr, seed uintptr) uint32 {
-	_i := *(*interface{})(iptr)
+	_i := *(*_interface)(iptr)
 	return hashmapInterfaceHash(_i, seed)
 }
 

src/runtime/interface.go

@@ -11,17 +11,17 @@ import (
 )
 
 type _interface struct {
-	typecode unsafe.Pointer
+	typecode uintptr
 	value    unsafe.Pointer
 }
 
 //go:inline
-func composeInterface(typecode, value unsafe.Pointer) _interface {
+func composeInterface(typecode uintptr, value unsafe.Pointer) _interface {
 	return _interface{typecode, value}
 }
 
 //go:inline
-func decomposeInterface(i _interface) (unsafe.Pointer, unsafe.Pointer) {
+func decomposeInterface(i _interface) (uintptr, unsafe.Pointer) {
 	return i.typecode, i.value
 }
 
@@ -34,7 +34,7 @@ func reflectValueEqual(x, y reflect.Value) bool {
 	// Note: doing a x.Type() == y.Type() comparison would not work here as that
 	// would introduce an infinite recursion: comparing two reflect.Type values
 	// is done with this reflectValueEqual runtime call.
-	if x.RawType() == nil || y.RawType() == nil {
+	if x.RawType() == 0 || y.RawType() == 0 {
 		// One of them is nil.
 		return x.RawType() == y.RawType()
 	}
@@ -94,13 +94,48 @@ func interfaceTypeAssert(ok bool) {
 // lowered to inline IR in the interface lowering pass.
 // See compiler/interface-lowering.go for details.
 
+type interfaceMethodInfo struct {
+	signature *uint8  // external *i8 with a name identifying the Go function signature
+	funcptr   uintptr // bitcast from the actual function pointer
+}
+
+type typecodeID struct {
+	// Depending on the type kind of this typecodeID, this pointer is something
+	// different:
+	// * basic types: null
+	// * named type: the underlying type
+	// * interface: null
+	// * chan/pointer/slice/array: the element type
+	// * struct: bitcast of global with structField array
+	// * func/map: TODO
+	references *typecodeID
+
+	// The array length, for array types.
+	length uintptr
+
+	methodSet *interfaceMethodInfo // nil or a GEP of an array
+
+	// The type that's a pointer to this type, nil if it is already a pointer.
+	// Keeping the type struct alive here is important so that values from
+	// reflect.New (which uses reflect.PtrTo) can be used in type asserts etc.
+	ptrTo *typecodeID
+
+	// typeAssert is a ptrtoint of a declared interface assert function.
+	// It only exists to make the rtcalls pass easier.
+	typeAssert uintptr
+}
+
+// structField is used by the compiler to pass information to the interface
+// lowering pass. It is not used in the final binary.
 type structField struct {
-	typecode unsafe.Pointer // type of this struct field
-	data     *uint8         // pointer to byte array containing name, tag, and 'embedded' flag
+	typecode *typecodeID // type of this struct field
+	name     *uint8      // pointer to char array
+	tag      *uint8      // pointer to char array, or nil
+	embedded bool
 }
 
 // Pseudo function call used during a type assert. It is used during interface
 // lowering, to assign the lowest type numbers to the types with the most type
 // asserts. Also, it is replaced with const false if this type assert can never
 // happen.
-func typeAssert(actualType unsafe.Pointer, assertedType *uint8) bool
+func typeAssert(actualType uintptr, assertedType *uint8) bool

src/runtime/interrupt/interrupt_avr.go

@@ -34,12 +34,3 @@ func Restore(state State) {
 		"state": state,
 	})
 }
-
-// In returns whether the system is currently in an interrupt.
-//
-// Warning: this always returns false on AVR, as there does not appear to be a
-// reliable way to determine whether we're currently running inside an interrupt
-// handler.
-func In() bool {
-	return false
-}

src/runtime/interrupt/interrupt_cortexm.go

@@ -50,13 +50,3 @@ func Disable() (state State) {
 func Restore(state State) {
 	arm.EnableInterrupts(uintptr(state))
 }
-
-// In returns whether the system is currently in an interrupt.
-func In() bool {
-	// The VECTACTIVE field gives the instruction vector that is currently
-	// active (in handler mode), or 0 if not in an interrupt.
-	// Documentation:
-	// https://developer.arm.com/documentation/dui0497/a/cortex-m0-peripherals/system-control-block/interrupt-control-and-state-register
-	vectactive := uint8(arm.SCB.ICSR.Get())
-	return vectactive != 0
-}

src/runtime/interrupt/interrupt_gameboyadvance.go

@@ -2,8 +2,6 @@
 
 package interrupt
 
-// This is good documentation of the GBA: https://www.akkit.org/info/gbatek.htm
-
 import (
 	"runtime/volatile"
 	"unsafe"
@@ -38,11 +36,8 @@ func (irq Interrupt) Enable() {
 	regInterruptEnable.SetBits(1 << uint(irq.num))
 }
 
-var inInterrupt bool
-
 //export handleInterrupt
 func handleInterrupt() {
-	inInterrupt = true
 	flags := regInterruptRequestFlags.Get()
 	for i := 0; i < 14; i++ {
 		if flags&(1<<uint(i)) != 0 {
@@ -50,7 +45,6 @@ func handleInterrupt() {
 			callInterruptHandler(i)
 		}
 	}
-	inInterrupt = false
 }
 
 // Pseudo function call that is replaced by the compiler with the actual
@@ -121,8 +115,3 @@ func Restore(state State) {
 	// Restore interrupts to the previous state.
 	regGlobalInterruptEnable.Set(uint16(state))
 }
-
-// In returns whether the system is currently in an interrupt.
-func In() bool {
-	return inInterrupt
-}

src/runtime/interrupt/interrupt_none.go

@@ -23,9 +23,3 @@ func Disable() (state State) {
 // calling Disable, this will not re-enable interrupts, allowing for nested
 // cricital sections.
 func Restore(state State) {}
-
-// In returns whether the system is currently in an interrupt.
-func In() bool {
-	// There are no interrupts, so it can't be in one.
-	return false
-}

src/runtime/interrupt/interrupt_tinygoriscv.go

@@ -27,12 +27,3 @@ func Disable() (state State) {
 func Restore(state State) {
 	riscv.EnableInterrupts(uintptr(state))
 }
-
-// In returns whether the system is currently in an interrupt.
-func In() bool {
-	// There is one exception that has the value 0 (instruction address
-	// misaligned), but it's not very likely and even if it happens, it's not
-	// really something that can be recovered from. Therefore I think it's safe
-	// to ignore it. It's handled specially (in handleException).
-	return riscv.MCAUSE.Get() != 0
-}

src/runtime/interrupt/interrupt_xtensa.go

@@ -29,11 +29,3 @@ func Restore(state State) {
 		"state": state,
 	})
 }
-
-// In returns whether the system is currently in an interrupt.
-//
-// Warning: interrupts have not been implemented for Xtensa yet so this always
-// returns false.
-func In() bool {
-	return false
-}

src/runtime/mstats.go

@@ -9,6 +9,11 @@ package runtime
 type MemStats struct {
 	// General statistics.
 
+	// Alloc is bytes of allocated heap objects.
+	//
+	// This is the same as HeapAlloc (see below).
+	Alloc uint64
+
 	// Sys is the total bytes of memory obtained from the OS.
 	//
 	// Sys is the sum of the XSys fields below. Sys measures the
@@ -18,6 +23,19 @@ type MemStats struct {
 
 	// Heap memory statistics.
 
+	// HeapAlloc is bytes of allocated heap objects.
+	//
+	// "Allocated" heap objects include all reachable objects, as
+	// well as unreachable objects that the garbage collector has
+	// not yet freed. Specifically, HeapAlloc increases as heap
+	// objects are allocated and decreases as the heap is swept
+	// and unreachable objects are freed. Sweeping occurs
+	// incrementally between GC cycles, so these two processes
+	// occur simultaneously, and as a result HeapAlloc tends to
+	// change smoothly (in contrast with the sawtooth that is
+	// typical of stop-the-world garbage collectors).
+	HeapAlloc uint64
+
 	// HeapSys is bytes of heap memory, total.
 	//
 	// In TinyGo unlike upstream Go, we make no distinction between

src/runtime/runtime.go

@@ -88,15 +88,16 @@ func LockOSThread() {
 func UnlockOSThread() {
 }
 
-// KeepAlive makes sure the value in the interface is alive until at least the
-// point of the call.
-func KeepAlive(x interface{})
+func KeepAlive(x interface{}) {
+	// Unimplemented. Only required with SetFinalizer().
+}
 
-var godebugUpdate func(string, string)
+func SetFinalizer(obj interface{}, finalizer interface{}) {
+	// Unimplemented.
+}
 
 //go:linkname godebug_setUpdate internal/godebug.setUpdate
 func godebug_setUpdate(update func(string, string)) {
-	// The 'update' function needs to be called whenever the GODEBUG environment
-	// variable changes (for example, via os.Setenv).
-	godebugUpdate = update
+	// Unimplemented. The 'update' function needs to be called whenever the
+	// GODEBUG environment variable changes (for example, via os.Setenv).
 }

src/runtime/runtime_fe310.go

@@ -25,12 +25,6 @@ func main() {
 	// Zero the threshold value to allow all priorities of interrupts.
 	sifive.PLIC.THRESHOLD.Set(0)
 
-	// Zero MCAUSE, which is set to the reset reason on reset. It must be zeroed
-	// to make interrupt.In() work.
-	// This would also be a good time to save the reset reason, but that hasn't
-	// been implemented yet.
-	riscv.MCAUSE.Set(0)
-
 	// Set the interrupt address.
 	// Note that this address must be aligned specially, otherwise the MODE bits
 	// of MTVEC won't be zero.
@@ -79,10 +73,6 @@ func handleInterrupt() {
 		// misaligned loads). However, for now we'll just print a fatal error.
 		handleException(code)
 	}
-
-	// Zero MCAUSE so that it can later be used to see whether we're in an
-	// interrupt or not.
-	riscv.MCAUSE.Set(0)
 }
 
 // initPeripherals configures periperhals the way the runtime expects them.

src/runtime/runtime_k210.go

@@ -31,12 +31,6 @@ func main() {
 		kendryte.PLIC.PRIORITY[i].Set(0)
 	}
 
-	// Zero MCAUSE, which is set to the reset reason on reset. It must be zeroed
-	// to make interrupt.In() work.
-	// This would also be a good time to save the reset reason, but that hasn't
-	// been implemented yet.
-	riscv.MCAUSE.Set(0)
-
 	// Set the interrupt address.
 	// Note that this address must be aligned specially, otherwise the MODE bits
 	// of MTVEC won't be zero.
@@ -99,10 +93,6 @@ func handleInterrupt() {
 		// misaligned loads). However, for now we'll just print a fatal error.
 		handleException(code)
 	}
-
-	// Zero MCAUSE so that it can later be used to see whether we're in an
-	// interrupt or not.
-	riscv.MCAUSE.Set(0)
 }
 
 // initPeripherals configures periperhals the way the runtime expects them.

src/syscall/syscall_libc.go

@@ -146,8 +146,6 @@ func Unlink(path string) (err error) {
 	return
 }
 
-func Faccessat(dirfd int, path string, mode uint32, flags int) (err error)
-
 func Kill(pid int, sig Signal) (err error) {
 	return ENOSYS // TODO
 }
@@ -292,18 +290,6 @@ func Environ() []string {
 	return envs
 }
 
-// BytePtrFromString returns a pointer to a NUL-terminated array of
-// bytes containing the text of s. If s contains a NUL byte at any
-// location, it returns (nil, EINVAL).
-func BytePtrFromString(s string) (*byte, error) {
-	for i := 0; i < len(s); i++ {
-		if s[i] == 0 {
-			return nil, EINVAL
-		}
-	}
-	return &cstring(s)[0], nil
-}
-
 // cstring converts a Go string to a C string.
 func cstring(s string) []byte {
 	data := make([]byte, len(s)+1)

src/syscall/syscall_libc_darwin.go

@@ -52,9 +52,6 @@ const (
 	DT_SOCK    = 0xc
 	DT_UNKNOWN = 0x0
 	DT_WHT     = 0xe
-	F_GETFL    = 0x3
-	F_SETFL    = 0x4
-	O_NONBLOCK = 0x4
 )
 
 // Source: https://opensource.apple.com/source/xnu/xnu-7195.81.3/bsd/sys/errno.h.auto.html
@@ -65,7 +62,6 @@ const (
 	EEXIST      Errno = 17
 	EINTR       Errno = 4
 	ENOTDIR     Errno = 20
-	EISDIR      Errno = 21
 	EINVAL      Errno = 22
 	EMFILE      Errno = 24
 	EPIPE       Errno = 32
@@ -275,32 +271,6 @@ func Getpagesize() int {
 	return int(libc_getpagesize())
 }
 
-// The following RawSockAddr* types have been copied from the Go source tree and
-// are here purely to fix build errors.
-
-type RawSockaddr struct {
-	Len    uint8
-	Family uint8
-	Data   [14]int8
-}
-
-type RawSockaddrInet4 struct {
-	Len    uint8
-	Family uint8
-	Port   uint16
-	Addr   [4]byte /* in_addr */
-	Zero   [8]int8
-}
-
-type RawSockaddrInet6 struct {
-	Len      uint8
-	Family   uint8
-	Port     uint16
-	Flowinfo uint32
-	Addr     [16]byte /* in6_addr */
-	Scope_id uint32
-}
-
 // int pipe(int32 *fds);
 //
 //export pipe

src/syscall/syscall_libc_nintendoswitch.go

@@ -71,14 +71,6 @@ func Getpagesize() int {
 	return 4096 // TODO
 }
 
-type RawSockaddrInet4 struct {
-	// stub
-}
-
-type RawSockaddrInet6 struct {
-	// stub
-}
-
 // int open(const char *pathname, int flags, mode_t mode);
 //
 //export open

src/syscall/syscall_libc_wasi.go

@@ -87,22 +87,6 @@ const (
 	PROT_READ  = 1
 	PROT_WRITE = 2
 	PROT_EXEC  = 4
-
-	// ../../lib/wasi-libc/expected/wasm32-wasi/predefined-macros.txt
-	F_GETFL = 3
-	F_SETFL = 4
-)
-
-// These values are needed as a stub until Go supports WASI as a full target.
-// The constant values don't have a meaning and don't correspond to anything
-// real.
-const (
-	_ = iota
-	SYS_FCNTL
-	SYS_FCNTL64
-	SYS_FSTATAT64
-	SYS_OPENAT
-	SYS_UNLINKAT
 )
 
 //go:extern errno
@@ -324,32 +308,6 @@ func Getpagesize() int {
 	return 65536
 }
 
-type Utsname struct {
-	Sysname    [65]int8
-	Nodename   [65]int8
-	Release    [65]int8
-	Version    [65]int8
-	Machine    [65]int8
-	Domainname [65]int8
-}
-
-// Stub Utsname, needed because WASI pretends to be linux/arm.
-func Uname(buf *Utsname) (err error)
-
-type RawSockaddrInet4 struct {
-	// stub
-}
-
-type RawSockaddrInet6 struct {
-	// stub
-}
-
-// This is a stub, it is not functional.
-func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
-
-// This is a stub, it is not functional.
-func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
-
 // int stat(const char *path, struct stat * buf);
 //
 //export stat

src/syscall/syscall_nonhosted.go

@@ -210,11 +210,3 @@ func Getpagesize() int {
 	// common assumption when pagesize is unknown
 	return 4096
 }
-
-type RawSockaddrInet4 struct {
-	// stub
-}
-
-type RawSockaddrInet6 struct {
-	// stub
-}

src/syscall/syscall_unix.go

@@ -1,18 +1,3 @@
 package syscall
 
 func Exec(argv0 string, argv []string, envv []string) (err error)
-
-// The two SockaddrInet* structs have been copied from the Go source tree.
-
-type SockaddrInet4 struct {
-	Port int
-	Addr [4]byte
-	raw  RawSockaddrInet4
-}
-
-type SockaddrInet6 struct {
-	Port   int
-	ZoneId uint32
-	Addr   [16]byte
-	raw    RawSockaddrInet6
-}

testdata/gc.go

@@ -1,7 +1,5 @@
 package main
 
-import "runtime"
-
 var xorshift32State uint32 = 1
 
 func xorshift32(x uint32) uint32 {
@@ -19,7 +17,6 @@ func randuint32() uint32 {
 
 func main() {
 	testNonPointerHeap()
-	testKeepAlive()
 }
 
 var scalarSlices [4][]byte
@@ -67,10 +64,3 @@ func testNonPointerHeap() {
 	}
 	println("ok")
 }
-
-func testKeepAlive() {
-	// There isn't much we can test, but at least we can test that
-	// runtime.KeepAlive compiles correctly.
-	var x int
-	runtime.KeepAlive(&x)
-}

testdata/map.go

@@ -129,8 +129,6 @@ func main() {
 	floatcmplx()
 
 	mapgrow()
-
-	interfacerehash()
 }
 
 func floatcmplx() {
@@ -276,35 +274,3 @@ func mapgrow() {
 	}
 	println("done")
 }
-
-type Counter interface {
-	count() int
-}
-
-type counter struct {
-	i int
-}
-
-func (c *counter) count() int {
-	return c.i
-}
-
-func interfacerehash() {
-	m := make(map[Counter]int)
-
-	for i := 0; i < 20; i++ {
-		c := &counter{i}
-		m[c] = i
-	}
-
-	var failures int
-	for k, v := range m {
-		if got := m[k]; got != v {
-			println("lookup failure got", got, "want", v)
-			failures++
-		}
-	}
-	if failures == 0 {
-		println("no interface lookup failures")
-	}
-}

testdata/map.txt

@@ -80,4 +80,3 @@ tested growing of a map
 2
 2
 done
-no interface lookup failures

testdata/reflect.go

@@ -3,7 +3,6 @@ package main
 import (
 	"errors"
 	"reflect"
-	"strconv"
 	"unsafe"
 )
 
@@ -18,8 +17,8 @@ type (
 		Y int16
 	}
 	mystruct struct {
-		n    int   `foo:"bar"`
-		some point "some\x00tag"
+		n    int `foo:"bar"`
+		some point
 		zero struct{}
 		buf  []byte
 		Buf  []byte
@@ -481,7 +480,7 @@ func showValue(rv reflect.Value, indent string) {
 		for i := 0; i < rv.NumField(); i++ {
 			field := rt.Field(i)
 			println(indent+"  field:", i, field.Name)
-			println(indent+"  tag:", strconv.Quote(string(field.Tag)))
+			println(indent+"  tag:", field.Tag)
 			println(indent+"  embedded:", field.Anonymous)
 			println(indent+"  exported:", field.IsExported())
 			showValue(rv.Field(i), indent+"  ")

testdata/reflect.txt

@@ -233,7 +233,7 @@ reflect type: struct
 reflect type: struct
   struct: 1
   field: 0 error
-  tag: ""
+  tag: 
   embedded: true
   exported: false
   reflect type: interface caninterface=false
@@ -242,19 +242,19 @@ reflect type: struct
 reflect type: struct
   struct: 3
   field: 0 a
-  tag: ""
+  tag: 
   embedded: false
   exported: false
   reflect type: uint8 caninterface=false
     uint: 42
   field: 1 b
-  tag: ""
+  tag: 
   embedded: false
   exported: false
   reflect type: int16 caninterface=false
     int: 321
   field: 2 c
-  tag: ""
+  tag: 
   embedded: false
   exported: false
   reflect type: int8 caninterface=false
@@ -262,37 +262,37 @@ reflect type: struct
 reflect type: struct comparable=false
   struct: 5
   field: 0 n
-  tag: "foo:\"bar\""
+  tag: foo:"bar"
   embedded: false
   exported: false
   reflect type: int caninterface=false
     int: 5
   field: 1 some
-  tag: "some\x00tag"
+  tag: 
   embedded: false
   exported: false
   reflect type: struct caninterface=false
     struct: 2
     field: 0 X
-    tag: ""
+    tag: 
     embedded: false
     exported: true
     reflect type: int16 caninterface=false
       int: -5
     field: 1 Y
-    tag: ""
+    tag: 
     embedded: false
     exported: true
     reflect type: int16 caninterface=false
       int: 3
   field: 2 zero
-  tag: ""
+  tag: 
   embedded: false
   exported: false
   reflect type: struct caninterface=false
     struct: 0
   field: 3 buf
-  tag: ""
+  tag: 
   embedded: false
   exported: false
   reflect type: slice caninterface=false comparable=false
@@ -306,7 +306,7 @@ reflect type: struct comparable=false
     reflect type: uint8 addrable=true caninterface=false
       uint: 111
   field: 4 Buf
-  tag: ""
+  tag: 
   embedded: false
   exported: true
   reflect type: slice comparable=false
@@ -322,14 +322,14 @@ reflect type: ptr
   reflect type: struct settable=true addrable=true
     struct: 2
     field: 0 next
-    tag: "description:\"chain\""
+    tag: description:"chain"
     embedded: false
     exported: false
     reflect type: ptr addrable=true caninterface=false
       pointer: false struct
       nil: true
     field: 1 foo
-    tag: ""
+    tag: 
     embedded: false
     exported: false
     reflect type: int addrable=true caninterface=false
@@ -337,13 +337,13 @@ reflect type: ptr
 reflect type: struct
   struct: 2
   field: 0 A
-  tag: ""
+  tag: 
   embedded: false
   exported: true
   reflect type: uintptr
     uint: 2
   field: 1 B
-  tag: ""
+  tag: 
   embedded: false
   exported: true
   reflect type: uintptr

tools/gen-device-svd/gen-device-svd.go

@@ -90,10 +90,9 @@ type SVDCluster struct {
 }
 
 type Device struct {
-	Metadata       *Metadata
-	Interrupts     []*Interrupt
-	Peripherals    []*Peripheral
-	PeripheralDict map[string]*Peripheral
+	Metadata    *Metadata
+	Interrupts  []*Interrupt
+	Peripherals []*Peripheral
 }
 
 type Metadata struct {
@@ -192,142 +191,6 @@ func cleanName(text string) string {
 	return text
 }
 
-func processSubCluster(p *Peripheral, cluster *SVDCluster, clusterOffset uint64, clusterName string, peripheralDict map[string]*Peripheral) []*Peripheral {
-	var peripheralsList []*Peripheral
-	clusterPrefix := clusterName + "_"
-	cpRegisters := []*PeripheralField{}
-
-	for _, regEl := range cluster.Registers {
-		cpRegisters = append(cpRegisters, parseRegister(p.GroupName, regEl, p.BaseAddress+clusterOffset, clusterPrefix)...)
-	}
-	// handle sub-clusters of registers
-	for _, subClusterEl := range cluster.Clusters {
-		subclusterName := strings.ReplaceAll(subClusterEl.Name, "[%s]", "")
-		subclusterPrefix := subclusterName + "_"
-		subclusterOffset, err := strconv.ParseUint(subClusterEl.AddressOffset, 0, 32)
-		if err != nil {
-			panic(err)
-		}
-		subdim := *subClusterEl.Dim
-		subdimIncrement, err := strconv.ParseInt(subClusterEl.DimIncrement, 0, 32)
-		if err != nil {
-			panic(err)
-		}
-
-		if subdim > 1 {
-			subcpRegisters := []*PeripheralField{}
-			for _, regEl := range subClusterEl.Registers {
-				subcpRegisters = append(subcpRegisters, parseRegister(p.GroupName, regEl, p.BaseAddress+clusterOffset+subclusterOffset, subclusterPrefix)...)
-			}
-
-			cpRegisters = append(cpRegisters, &PeripheralField{
-				Name:        subclusterName,
-				Address:     p.BaseAddress + clusterOffset + subclusterOffset,
-				Description: subClusterEl.Description,
-				Registers:   subcpRegisters,
-				Array:       subdim,
-				ElementSize: int(subdimIncrement),
-				ShortName:   clusterPrefix + subclusterName,
-			})
-		} else {
-			for _, regEl := range subClusterEl.Registers {
-				cpRegisters = append(cpRegisters, parseRegister(regEl.Name, regEl, p.BaseAddress+clusterOffset+subclusterOffset, subclusterPrefix)...)
-			}
-		}
-	}
-
-	sort.SliceStable(cpRegisters, func(i, j int) bool {
-		return cpRegisters[i].Address < cpRegisters[j].Address
-	})
-	clusterPeripheral := &Peripheral{
-		Name:        p.Name + "_" + clusterName,
-		GroupName:   p.GroupName + "_" + clusterName,
-		Description: p.Description + " - " + clusterName,
-		ClusterName: clusterName,
-		BaseAddress: p.BaseAddress + clusterOffset,
-		Registers:   cpRegisters,
-	}
-	peripheralsList = append(peripheralsList, clusterPeripheral)
-	peripheralDict[clusterPeripheral.Name] = clusterPeripheral
-	p.Subtypes = append(p.Subtypes, clusterPeripheral)
-
-	return peripheralsList
-}
-
-func processCluster(p *Peripheral, clusters []*SVDCluster, peripheralDict map[string]*Peripheral) []*Peripheral {
-	var peripheralsList []*Peripheral
-	for _, cluster := range clusters {
-		clusterName := strings.ReplaceAll(cluster.Name, "[%s]", "")
-		if cluster.DimIndex != nil {
-			clusterName = strings.ReplaceAll(clusterName, "%s", "")
-		}
-		clusterPrefix := clusterName + "_"
-		clusterOffset, err := strconv.ParseUint(cluster.AddressOffset, 0, 32)
-		if err != nil {
-			panic(err)
-		}
-		var dim, dimIncrement int
-		if cluster.Dim == nil {
-			// Nordic SVD have sub-clusters with another sub-clusters.
-			if clusterOffset == 0 || len(cluster.Clusters) > 0 {
-				peripheralsList = append(peripheralsList, processSubCluster(p, cluster, clusterOffset, clusterName, peripheralDict)...)
-				continue
-			}
-			dim = -1
-			dimIncrement = -1
-		} else {
-			dim = *cluster.Dim
-			if dim == 1 {
-				dimIncrement = -1
-			} else {
-				inc, err := strconv.ParseUint(cluster.DimIncrement, 0, 32)
-				if err != nil {
-					panic(err)
-				}
-				dimIncrement = int(inc)
-			}
-		}
-		clusterRegisters := []*PeripheralField{}
-		for _, regEl := range cluster.Registers {
-			regName := p.GroupName
-			if regName == "" {
-				regName = p.Name
-			}
-			clusterRegisters = append(clusterRegisters, parseRegister(regName, regEl, p.BaseAddress+clusterOffset, clusterPrefix)...)
-		}
-		sort.SliceStable(clusterRegisters, func(i, j int) bool {
-			return clusterRegisters[i].Address < clusterRegisters[j].Address
-		})
-		if dimIncrement == -1 && len(clusterRegisters) > 0 {
-			lastReg := clusterRegisters[len(clusterRegisters)-1]
-			lastAddress := lastReg.Address
-			if lastReg.Array != -1 {
-				lastAddress = lastReg.Address + uint64(lastReg.Array*lastReg.ElementSize)
-			}
-			firstAddress := clusterRegisters[0].Address
-			dimIncrement = int(lastAddress - firstAddress)
-		}
-
-		if !unicode.IsUpper(rune(clusterName[0])) && !unicode.IsDigit(rune(clusterName[0])) {
-			clusterName = strings.ToUpper(clusterName)
-		}
-
-		p.Registers = append(p.Registers, &PeripheralField{
-			Name:        clusterName,
-			Address:     p.BaseAddress + clusterOffset,
-			Description: cluster.Description,
-			Registers:   clusterRegisters,
-			Array:       dim,
-			ElementSize: dimIncrement,
-			ShortName:   clusterName,
-		})
-	}
-	sort.SliceStable(p.Registers, func(i, j int) bool {
-		return p.Registers[i].Address < p.Registers[j].Address
-	})
-	return peripheralsList
-}
-
 // Read ARM SVD files.
 func readSVD(path, sourceURL string) (*Device, error) {
 	// Open the XML file.
@@ -430,7 +293,133 @@ func readSVD(path, sourceURL string) (*Device, error) {
 			}
 			p.Registers = append(p.Registers, parseRegister(regName, register, baseAddress, "")...)
 		}
-		peripheralsList = append(peripheralsList, processCluster(p, periphEl.Clusters, peripheralDict)...)
+		for _, cluster := range periphEl.Clusters {
+			clusterName := strings.ReplaceAll(cluster.Name, "[%s]", "")
+			if cluster.DimIndex != nil {
+				clusterName = strings.ReplaceAll(clusterName, "%s", "")
+			}
+			clusterPrefix := clusterName + "_"
+			clusterOffset, err := strconv.ParseUint(cluster.AddressOffset, 0, 32)
+			if err != nil {
+				panic(err)
+			}
+			var dim, dimIncrement int
+			if cluster.Dim == nil {
+				if clusterOffset == 0 {
+					// make this a separate peripheral
+					cpRegisters := []*PeripheralField{}
+					for _, regEl := range cluster.Registers {
+						cpRegisters = append(cpRegisters, parseRegister(groupName, regEl, baseAddress, clusterName+"_")...)
+					}
+					// handle sub-clusters of registers
+					for _, subClusterEl := range cluster.Clusters {
+						subclusterName := strings.ReplaceAll(subClusterEl.Name, "[%s]", "")
+						subclusterPrefix := subclusterName + "_"
+						subclusterOffset, err := strconv.ParseUint(subClusterEl.AddressOffset, 0, 32)
+						if err != nil {
+							panic(err)
+						}
+						subdim := *subClusterEl.Dim
+						subdimIncrement, err := strconv.ParseInt(subClusterEl.DimIncrement, 0, 32)
+						if err != nil {
+							panic(err)
+						}
+
+						if subdim > 1 {
+							subcpRegisters := []*PeripheralField{}
+							subregSize := 0
+							for _, regEl := range subClusterEl.Registers {
+								size, err := strconv.ParseInt(*regEl.Size, 0, 32)
+								if err != nil {
+									panic(err)
+								}
+								subregSize += int(size)
+								subcpRegisters = append(subcpRegisters, parseRegister(groupName, regEl, baseAddress+subclusterOffset, subclusterPrefix)...)
+							}
+							cpRegisters = append(cpRegisters, &PeripheralField{
+								Name:        subclusterName,
+								Address:     baseAddress + subclusterOffset,
+								Description: subClusterEl.Description,
+								Registers:   subcpRegisters,
+								Array:       subdim,
+								ElementSize: int(subdimIncrement),
+								ShortName:   clusterPrefix + subclusterName,
+							})
+						} else {
+							for _, regEl := range subClusterEl.Registers {
+								cpRegisters = append(cpRegisters, parseRegister(regEl.Name, regEl, baseAddress+subclusterOffset, subclusterPrefix)...)
+							}
+						}
+					}
+
+					sort.SliceStable(cpRegisters, func(i, j int) bool {
+						return cpRegisters[i].Address < cpRegisters[j].Address
+					})
+					clusterPeripheral := &Peripheral{
+						Name:        periphEl.Name + "_" + clusterName,
+						GroupName:   groupName + "_" + clusterName,
+						Description: description + " - " + clusterName,
+						ClusterName: clusterName,
+						BaseAddress: baseAddress,
+						Registers:   cpRegisters,
+					}
+					peripheralsList = append(peripheralsList, clusterPeripheral)
+					peripheralDict[clusterPeripheral.Name] = clusterPeripheral
+					p.Subtypes = append(p.Subtypes, clusterPeripheral)
+					continue
+				}
+				dim = -1
+				dimIncrement = -1
+			} else {
+				dim = *cluster.Dim
+				if dim == 1 {
+					dimIncrement = -1
+				} else {
+					inc, err := strconv.ParseUint(cluster.DimIncrement, 0, 32)
+					if err != nil {
+						panic(err)
+					}
+					dimIncrement = int(inc)
+				}
+			}
+			clusterRegisters := []*PeripheralField{}
+			for _, regEl := range cluster.Registers {
+				regName := groupName
+				if regName == "" {
+					regName = periphEl.Name
+				}
+				clusterRegisters = append(clusterRegisters, parseRegister(regName, regEl, baseAddress+clusterOffset, clusterPrefix)...)
+			}
+			sort.SliceStable(clusterRegisters, func(i, j int) bool {
+				return clusterRegisters[i].Address < clusterRegisters[j].Address
+			})
+			if dimIncrement == -1 && len(clusterRegisters) > 0 {
+				lastReg := clusterRegisters[len(clusterRegisters)-1]
+				lastAddress := lastReg.Address
+				if lastReg.Array != -1 {
+					lastAddress = lastReg.Address + uint64(lastReg.Array*lastReg.ElementSize)
+				}
+				firstAddress := clusterRegisters[0].Address
+				dimIncrement = int(lastAddress - firstAddress)
+			}
+
+			if !unicode.IsUpper(rune(clusterName[0])) && !unicode.IsDigit(rune(clusterName[0])) {
+				clusterName = strings.ToUpper(clusterName)
+			}
+
+			p.Registers = append(p.Registers, &PeripheralField{
+				Name:        clusterName,
+				Address:     baseAddress + clusterOffset,
+				Description: cluster.Description,
+				Registers:   clusterRegisters,
+				Array:       dim,
+				ElementSize: dimIncrement,
+				ShortName:   clusterName,
+			})
+		}
+		sort.SliceStable(p.Registers, func(i, j int) bool {
+			return p.Registers[i].Address < p.Registers[j].Address
+		})
 	}
 
 	// Make a sorted list of interrupts.
@@ -470,10 +459,9 @@ func readSVD(path, sourceURL string) (*Device, error) {
 		metadata.NVICPrioBits = device.CPU.NVICPrioBits
 	}
 	return &Device{
-		Metadata:       metadata,
-		Interrupts:     interruptList,
-		Peripherals:    peripheralsList,
-		PeripheralDict: peripheralDict,
+		Metadata:    metadata,
+		Interrupts:  interruptList,
+		Peripherals: peripheralsList,
 	}, nil
 }
 
@@ -991,11 +979,10 @@ var (
 
 		address := peripheral.BaseAddress
 		type clusterInfo struct {
-			name        string
-			description string
-			address     uint64
-			size        uint64
-			registers   []*PeripheralField
+			name      string
+			address   uint64
+			size      uint64
+			registers []*PeripheralField
 		}
 		clusters := []clusterInfo{}
 		for _, register := range peripheral.Registers {
@@ -1037,7 +1024,7 @@ var (
 			if register.Registers != nil {
 				// This is a cluster, not a register. Create the cluster type.
 				regType = peripheral.GroupName + "_" + register.Name
-				clusters = append(clusters, clusterInfo{regType, register.Description, register.Address, uint64(register.ElementSize), register.Registers})
+				clusters = append(clusters, clusterInfo{regType, register.Address, uint64(register.ElementSize), register.Registers})
 				regType = regType + "_Type"
 				subaddress := register.Address
 				for _, subregister := range register.Registers {
@@ -1088,16 +1075,7 @@ var (
 				continue
 			}
 
-			if _, ok := device.PeripheralDict[cluster.name]; ok {
-				continue
-			}
-
 			fmt.Fprintln(w)
-			if cluster.description != "" {
-				for _, l := range splitLine(cluster.description) {
-					fmt.Fprintf(w, "// %s\n", l)
-				}
-			}
 			fmt.Fprintf(w, "type %s_Type struct {\n", cluster.name)
 
 			address := cluster.address
@@ -1138,7 +1116,7 @@ var (
 				if register.Registers != nil {
 					// This is a cluster, not a register. Create the cluster type.
 					regType = peripheral.GroupName + "_" + register.Name
-					clusters = append(clusters, clusterInfo{regType, register.Description, register.Address, uint64(register.ElementSize), register.Registers})
+					clusters = append(clusters, clusterInfo{regType, register.Address, uint64(register.ElementSize), register.Registers})
 					regType = regType + "_Type"
 
 					subaddress := register.Address

transform/globals.go

@@ -0,0 +1,20 @@
+package transform
+
+import "tinygo.org/x/go-llvm"
+
+// This file implements small transformations on globals (functions and global
+// variables) for specific ABIs/architectures.
+
+// ApplyFunctionSections puts every function in a separate section. This makes
+// it possible for the linker to remove dead code. It is the equivalent of
+// passing -ffunction-sections to a C compiler.
+func ApplyFunctionSections(mod llvm.Module) {
+	llvmFn := mod.FirstFunction()
+	for !llvmFn.IsNil() {
+		if !llvmFn.IsDeclaration() && llvmFn.Section() == "" {
+			name := llvmFn.Name()
+			llvmFn.SetSection(".text." + name)
+		}
+		llvmFn = llvm.NextFunction(llvmFn)
+	}
+}

transform/globals_test.go

@@ -0,0 +1,15 @@
+package transform_test
+
+import (
+	"testing"
+
+	"github.com/tinygo-org/tinygo/transform"
+	"tinygo.org/x/go-llvm"
+)
+
+func TestApplyFunctionSections(t *testing.T) {
+	t.Parallel()
+	testTransform(t, "testdata/globals-function-sections", func(mod llvm.Module) {
+		transform.ApplyFunctionSections(mod)
+	})
+}

transform/interface-lowering.go

@@ -13,7 +13,8 @@ package transform
 //
 // typeAssert:
 //     Replaced with an icmp instruction so it can be directly used in a type
-//     switch.
+//     switch. This is very easy to optimize for LLVM: it will often translate a
+//     type switch into a regular switch statement.
 //
 // interface type assert:
 //     These functions are defined by creating a big type switch over all the
@@ -53,11 +54,10 @@ type methodInfo struct {
 // typeInfo describes a single concrete Go type, which can be a basic or a named
 // type. If it is a named type, it may have methods.
 type typeInfo struct {
-	name        string
-	typecode    llvm.Value
-	typecodeGEP llvm.Value
-	methodSet   llvm.Value
-	methods     []*methodInfo
+	name      string
+	typecode  llvm.Value
+	methodSet llvm.Value
+	methods   []*methodInfo
 }
 
 // getMethod looks up the method on this type with the given signature and
@@ -91,8 +91,6 @@ type lowerInterfacesPass struct {
 	difiles     map[string]llvm.Metadata
 	ctx         llvm.Context
 	uintptrType llvm.Type
-	targetData  llvm.TargetData
-	i8ptrType   llvm.Type
 	types       map[string]*typeInfo
 	signatures  map[string]*signatureInfo
 	interfaces  map[string]*interfaceInfo
@@ -103,17 +101,14 @@ type lowerInterfacesPass struct {
 // before LLVM can work on them. This is done so that a few cleanup passes can
 // run before assigning the final type codes.
 func LowerInterfaces(mod llvm.Module, config *compileopts.Config) error {
-	ctx := mod.Context()
 	targetData := llvm.NewTargetData(mod.DataLayout())
 	defer targetData.Dispose()
 	p := &lowerInterfacesPass{
 		mod:         mod,
 		config:      config,
-		builder:     ctx.NewBuilder(),
-		ctx:         ctx,
-		targetData:  targetData,
+		builder:     mod.Context().NewBuilder(),
+		ctx:         mod.Context(),
 		uintptrType: mod.Context().IntType(targetData.PointerSize() * 8),
-		i8ptrType:   llvm.PointerType(ctx.Int8Type(), 0),
 		types:       make(map[string]*typeInfo),
 		signatures:  make(map[string]*signatureInfo),
 		interfaces:  make(map[string]*interfaceInfo),
@@ -156,26 +151,11 @@ func (p *lowerInterfacesPass) run() error {
 				}
 				p.types[name] = t
 				initializer := global.Initializer()
-				firstField := p.builder.CreateExtractValue(initializer, 0, "")
-				if firstField.Type() != p.ctx.Int8Type() {
-					// This type has a method set at index 0. Change the GEP to
-					// point to index 1 (the meta byte).
-					t.typecodeGEP = llvm.ConstGEP(global.GlobalValueType(), global, []llvm.Value{
-						llvm.ConstInt(p.ctx.Int32Type(), 0, false),
-						llvm.ConstInt(p.ctx.Int32Type(), 1, false),
-					})
-					methodSet := stripPointerCasts(firstField)
-					if !strings.HasSuffix(methodSet.Name(), "$methodset") {
-						panic("expected method set")
-					}
-					p.addTypeMethods(t, methodSet)
-				} else {
-					// This type has no method set.
-					t.typecodeGEP = llvm.ConstGEP(global.GlobalValueType(), global, []llvm.Value{
-						llvm.ConstInt(p.ctx.Int32Type(), 0, false),
-						llvm.ConstInt(p.ctx.Int32Type(), 0, false),
-					})
+				if initializer.IsNil() {
+					continue
 				}
+				methodSet := p.builder.CreateExtractValue(initializer, 2, "")
+				p.addTypeMethods(t, methodSet)
 			}
 		}
 	}
@@ -286,10 +266,10 @@ func (p *lowerInterfacesPass) run() error {
 		actualType := use.Operand(0)
 		name := strings.TrimPrefix(use.Operand(1).Name(), "reflect/types.typeid:")
 		if t, ok := p.types[name]; ok {
-			// The type exists in the program, so lower to a regular pointer
+			// The type exists in the program, so lower to a regular integer
 			// comparison.
 			p.builder.SetInsertPointBefore(use)
-			commaOk := p.builder.CreateICmp(llvm.IntEQ, t.typecodeGEP, actualType, "typeassert.ok")
+			commaOk := p.builder.CreateICmp(llvm.IntEQ, llvm.ConstPtrToInt(t.typecode, p.uintptrType), actualType, "typeassert.ok")
 			use.ReplaceAllUsesWith(commaOk)
 		} else {
 			// The type does not exist in the program, so lower to a constant
@@ -303,45 +283,15 @@ func (p *lowerInterfacesPass) run() error {
 	}
 
 	// Remove all method sets, which are now unnecessary and inhibit later
-	// optimizations if they are left in place.
-	zero := llvm.ConstInt(p.ctx.Int32Type(), 0, false)
+	// optimizations if they are left in place. Also remove references to the
+	// interface type assert functions just to be sure.
+	zeroUintptr := llvm.ConstNull(p.uintptrType)
 	for _, t := range p.types {
-		if !t.methodSet.IsNil() {
-			initializer := t.typecode.Initializer()
-			var newInitializerFields []llvm.Value
-			for i := 1; i < initializer.Type().StructElementTypesCount(); i++ {
-				newInitializerFields = append(newInitializerFields, p.builder.CreateExtractValue(initializer, i, ""))
-			}
-			newInitializer := p.ctx.ConstStruct(newInitializerFields, false)
-			typecodeName := t.typecode.Name()
-			newGlobal := llvm.AddGlobal(p.mod, newInitializer.Type(), typecodeName+".tmp")
-			newGlobal.SetInitializer(newInitializer)
-			newGlobal.SetLinkage(t.typecode.Linkage())
-			newGlobal.SetGlobalConstant(true)
-			newGlobal.SetAlignment(t.typecode.Alignment())
-			for _, use := range getUses(t.typecode) {
-				if !use.IsAConstantExpr().IsNil() {
-					opcode := use.Opcode()
-					if opcode == llvm.GetElementPtr && use.OperandsCount() == 3 {
-						if use.Operand(1).ZExtValue() == 0 && use.Operand(2).ZExtValue() == 1 {
-							gep := p.builder.CreateInBoundsGEP(newGlobal.GlobalValueType(), newGlobal, []llvm.Value{zero, zero}, "")
-							use.ReplaceAllUsesWith(gep)
-						}
-					}
-				}
-			}
-			// Fallback.
-			if hasUses(t.typecode) {
-				bitcast := llvm.ConstBitCast(newGlobal, p.i8ptrType)
-				negativeOffset := -int64(p.targetData.TypeAllocSize(p.i8ptrType))
-				gep := p.builder.CreateInBoundsGEP(p.ctx.Int8Type(), bitcast, []llvm.Value{llvm.ConstInt(p.ctx.Int32Type(), uint64(negativeOffset), true)}, "")
-				bitcast2 := llvm.ConstBitCast(gep, t.typecode.Type())
-				t.typecode.ReplaceAllUsesWith(bitcast2)
-			}
-			t.typecode.EraseFromParentAsGlobal()
-			newGlobal.SetName(typecodeName)
-			t.typecode = newGlobal
-		}
+		initializer := t.typecode.Initializer()
+		methodSet := p.builder.CreateExtractValue(initializer, 2, "")
+		initializer = p.builder.CreateInsertValue(initializer, llvm.ConstNull(methodSet.Type()), 2, "")
+		initializer = p.builder.CreateInsertValue(initializer, zeroUintptr, 4, "")
+		t.typecode.SetInitializer(initializer)
 	}
 
 	return nil
@@ -351,22 +301,22 @@ func (p *lowerInterfacesPass) run() error {
 // retrieves the signatures and the references to the method functions
 // themselves for later type<->interface matching.
 func (p *lowerInterfacesPass) addTypeMethods(t *typeInfo, methodSet llvm.Value) {
-	if !t.methodSet.IsNil() {
+	if !t.methodSet.IsNil() || methodSet.IsNull() {
 		// no methods or methods already read
 		return
 	}
+	if !methodSet.IsAConstantExpr().IsNil() && methodSet.Opcode() == llvm.GetElementPtr {
+		methodSet = methodSet.Operand(0) // get global from GEP, for LLVM 14 (non-opaque pointers)
+	}
 
 	// This type has methods, collect all methods of this type.
 	t.methodSet = methodSet
 	set := methodSet.Initializer() // get value from global
-	signatures := p.builder.CreateExtractValue(set, 1, "")
-	wrappers := p.builder.CreateExtractValue(set, 2, "")
-	numMethods := signatures.Type().ArrayLength()
-	for i := 0; i < numMethods; i++ {
-		signatureGlobal := p.builder.CreateExtractValue(signatures, i, "")
-		function := p.builder.CreateExtractValue(wrappers, i, "")
-		function = stripPointerCasts(function) // strip bitcasts
+	for i := 0; i < set.Type().ArrayLength(); i++ {
+		methodData := p.builder.CreateExtractValue(set, i, "")
+		signatureGlobal := p.builder.CreateExtractValue(methodData, 0, "")
 		signatureName := signatureGlobal.Name()
+		function := p.builder.CreateExtractValue(methodData, 1, "").Operand(0)
 		signature := p.getSignature(signatureName)
 		method := &methodInfo{
 			function:      function,
@@ -451,7 +401,7 @@ func (p *lowerInterfacesPass) defineInterfaceImplementsFunc(fn llvm.Value, itf *
 	actualType := fn.Param(0)
 	for _, typ := range itf.types {
 		nextBlock := p.ctx.AddBasicBlock(fn, typ.name+".next")
-		cmp := p.builder.CreateICmp(llvm.IntEQ, actualType, typ.typecodeGEP, typ.name+".icmp")
+		cmp := p.builder.CreateICmp(llvm.IntEQ, actualType, llvm.ConstPtrToInt(typ.typecode, p.uintptrType), typ.name+".icmp")
 		p.builder.CreateCondBr(cmp, thenBlock, nextBlock)
 		p.builder.SetInsertPointAtEnd(nextBlock)
 	}
@@ -490,7 +440,7 @@ func (p *lowerInterfacesPass) defineInterfaceMethodFunc(fn llvm.Value, itf *inte
 		params[i] = fn.Param(i + 1)
 	}
 	params = append(params,
-		llvm.Undef(p.i8ptrType),
+		llvm.Undef(llvm.PointerType(p.ctx.Int8Type(), 0)),
 	)
 
 	// Start chain in the entry block.
@@ -522,7 +472,7 @@ func (p *lowerInterfacesPass) defineInterfaceMethodFunc(fn llvm.Value, itf *inte
 		// Create type check (if/else).
 		bb := p.ctx.AddBasicBlock(fn, typ.name)
 		next := p.ctx.AddBasicBlock(fn, typ.name+".next")
-		cmp := p.builder.CreateICmp(llvm.IntEQ, actualType, typ.typecodeGEP, typ.name+".icmp")
+		cmp := p.builder.CreateICmp(llvm.IntEQ, actualType, llvm.ConstPtrToInt(typ.typecode, p.uintptrType), typ.name+".icmp")
 		p.builder.CreateCondBr(cmp, bb, next)
 
 		// The function we will redirect to when the interface has this type.
@@ -572,7 +522,7 @@ func (p *lowerInterfacesPass) defineInterfaceMethodFunc(fn llvm.Value, itf *inte
 	// method on a nil interface.
 	nilPanic := p.mod.NamedFunction("runtime.nilPanic")
 	p.builder.CreateCall(nilPanic.GlobalValueType(), nilPanic, []llvm.Value{
-		llvm.Undef(p.i8ptrType),
+		llvm.Undef(llvm.PointerType(p.ctx.Int8Type(), 0)),
 	}, "")
 	p.builder.CreateUnreachable()
 }

transform/optimizer.go

@@ -116,6 +116,7 @@ func Optimize(mod llvm.Module, config *compileopts.Config, optLevel, sizeLevel i
 		goPasses.Run(mod)
 
 		// Run TinyGo-specific interprocedural optimizations.
+		LowerReflect(mod)
 		OptimizeAllocs(mod, config.Options.PrintAllocs, func(pos token.Position, msg string) {
 			fmt.Fprintln(os.Stderr, pos.String()+": "+msg)
 		})
@@ -128,6 +129,7 @@ func Optimize(mod llvm.Module, config *compileopts.Config, optLevel, sizeLevel i
 		if err != nil {
 			return []error{err}
 		}
+		LowerReflect(mod)
 		errs := LowerInterrupts(mod)
 		if len(errs) > 0 {
 			return errs

transform/reflect.go

@@ -0,0 +1,567 @@
+package transform
+
+// This file has some compiler support for run-time reflection using the reflect
+// package. In particular, it encodes type information in type codes in such a
+// way that the reflect package can decode the type from this information.
+// Where needed, it also adds some side tables for looking up more information
+// about a type, when that information cannot be stored directly in the type
+// code.
+//
+// Go has 26 different type kinds.
+//
+// Type kinds are subdivided in basic types (see the list of basicTypes below)
+// that are mostly numeric literals and non-basic (or "complex") types that are
+// more difficult to encode. These non-basic types come in two forms:
+//   * Prefix types (pointer, slice, interface, channel): these just add
+//     something to an existing type. For example, a pointer like *int just adds
+//     the fact that it's a pointer to an existing type (int).
+//     These are encoded efficiently by adding a prefix to a type code.
+//   * Types with multiple fields (struct, array, func, map). All of these have
+//     multiple fields contained within. Most obviously structs can contain many
+//     types as fields. Also arrays contain not just the element type but also
+//     the length parameter which can be any arbitrary number and thus may not
+//     fit in a type code.
+//     These types are encoded using side tables.
+//
+// This distinction is also important for how named types are encoded. At the
+// moment, named basic type just get a unique number assigned while named
+// non-basic types have their underlying type stored in a sidetable.
+
+import (
+	"encoding/binary"
+	"go/ast"
+	"math/big"
+	"sort"
+	"strings"
+
+	"tinygo.org/x/go-llvm"
+)
+
+// A list of basic types and their numbers. This list should be kept in sync
+// with the list of Kind constants of type.go in the reflect package.
+var basicTypes = map[string]int64{
+	"bool":           1,
+	"int":            2,
+	"int8":           3,
+	"int16":          4,
+	"int32":          5,
+	"int64":          6,
+	"uint":           7,
+	"uint8":          8,
+	"uint16":         9,
+	"uint32":         10,
+	"uint64":         11,
+	"uintptr":        12,
+	"float32":        13,
+	"float64":        14,
+	"complex64":      15,
+	"complex128":     16,
+	"string":         17,
+	"unsafe.Pointer": 18,
+}
+
+// A list of non-basic types. Adding 19 to this number will give the Kind as
+// used in src/reflect/types.go, and it must be kept in sync with that list.
+var nonBasicTypes = map[string]int64{
+	"chan":      0,
+	"interface": 1,
+	"pointer":   2,
+	"slice":     3,
+	"array":     4,
+	"func":      5,
+	"map":       6,
+	"struct":    7,
+}
+
+// typeCodeAssignmentState keeps some global state around for type code
+// assignments, used to assign one unique type code to each Go type.
+type typeCodeAssignmentState struct {
+	// Builder used purely for constant operations (because LLVM 15 removed many
+	// llvm.Const* functions).
+	builder llvm.Builder
+
+	// An integer that's incremented each time it's used to give unique IDs to
+	// type codes that are not yet fully supported otherwise by the reflect
+	// package (or are simply unused in the compiled program).
+	fallbackIndex int
+
+	// This is the length of an uintptr. Only used occasionally to know whether
+	// a given number can be encoded as a varint.
+	uintptrLen int
+
+	// Map of named types to their type code. It is important that named types
+	// get unique IDs for each type.
+	namedBasicTypes    map[string]int
+	namedNonBasicTypes map[string]int
+
+	// Map of array types to their type code.
+	arrayTypes               map[string]int
+	arrayTypesSidetable      []byte
+	needsArrayTypesSidetable bool
+
+	// Map of struct types to their type code.
+	structTypes               map[string]int
+	structTypesSidetable      []byte
+	needsStructNamesSidetable bool
+
+	// Map of struct names and tags to their name string.
+	structNames               map[string]int
+	structNamesSidetable      []byte
+	needsStructTypesSidetable bool
+
+	// This byte array is stored in reflect.namedNonBasicTypesSidetable and is
+	// used at runtime to get details about a named non-basic type.
+	// Entries are varints (see makeVarint below and readVarint in
+	// reflect/sidetables.go for the encoding): one varint per entry. The
+	// integers in namedNonBasicTypes are indices into this array. Because these
+	// are varints, most type codes are really small (just one byte).
+	//
+	// Note that this byte buffer is not created when it is not needed
+	// (reflect.namedNonBasicTypesSidetable has no uses), see
+	// needsNamedTypesSidetable.
+	namedNonBasicTypesSidetable []uint64
+
+	// This indicates whether namedNonBasicTypesSidetable needs to be created at
+	// all. If it is false, namedNonBasicTypesSidetable will contain simple
+	// monotonically increasing numbers.
+	needsNamedNonBasicTypesSidetable bool
+}
+
+// LowerReflect is used to assign a type code to each type in the program
+// that is ever stored in an interface. It tries to use the smallest possible
+// numbers to make the code that works with interfaces as small as possible.
+func LowerReflect(mod llvm.Module) {
+	// if reflect were not used, we could skip generating the sidetable
+	// this does not help in practice, and is difficult to do correctly
+
+	// Obtain slice of all types in the program.
+	type typeInfo struct {
+		typecode llvm.Value
+		name     string
+		numUses  int
+	}
+	var types []*typeInfo
+	for global := mod.FirstGlobal(); !global.IsNil(); global = llvm.NextGlobal(global) {
+		if strings.HasPrefix(global.Name(), "reflect/types.type:") {
+			types = append(types, &typeInfo{
+				typecode: global,
+				name:     global.Name(),
+				numUses:  len(getUses(global)),
+			})
+		}
+	}
+
+	// Sort the slice in a way that often used types are assigned a type code
+	// first.
+	sort.Slice(types, func(i, j int) bool {
+		if types[i].numUses != types[j].numUses {
+			return types[i].numUses < types[j].numUses
+		}
+		// It would make more sense to compare the name in the other direction,
+		// but for some reason that increases binary size. Could be a fluke, but
+		// could also have some good reason (and possibly hint at a small
+		// optimization).
+		return types[i].name > types[j].name
+	})
+
+	// Assign typecodes the way the reflect package expects.
+	targetData := llvm.NewTargetData(mod.DataLayout())
+	defer targetData.Dispose()
+	uintptrType := mod.Context().IntType(targetData.PointerSize() * 8)
+	state := typeCodeAssignmentState{
+		builder:                          mod.Context().NewBuilder(),
+		fallbackIndex:                    1,
+		uintptrLen:                       targetData.PointerSize() * 8,
+		namedBasicTypes:                  make(map[string]int),
+		namedNonBasicTypes:               make(map[string]int),
+		arrayTypes:                       make(map[string]int),
+		structTypes:                      make(map[string]int),
+		structNames:                      make(map[string]int),
+		needsNamedNonBasicTypesSidetable: len(getUses(mod.NamedGlobal("reflect.namedNonBasicTypesSidetable"))) != 0,
+		needsStructTypesSidetable:        len(getUses(mod.NamedGlobal("reflect.structTypesSidetable"))) != 0,
+		needsStructNamesSidetable:        len(getUses(mod.NamedGlobal("reflect.structNamesSidetable"))) != 0,
+		needsArrayTypesSidetable:         len(getUses(mod.NamedGlobal("reflect.arrayTypesSidetable"))) != 0,
+	}
+	defer state.builder.Dispose()
+	for _, t := range types {
+		num := state.getTypeCodeNum(t.typecode)
+		if num.BitLen() > state.uintptrLen || !num.IsUint64() {
+			// TODO: support this in some way, using a side table for example.
+			// That's less efficient but better than not working at all.
+			// Particularly important on systems with 16-bit pointers (e.g.
+			// AVR).
+			panic("compiler: could not store type code number inside interface type code")
+		}
+
+		// Replace each use of the type code global with the constant type code.
+		for _, use := range getUses(t.typecode) {
+			if use.IsAConstantExpr().IsNil() {
+				continue
+			}
+			typecode := llvm.ConstInt(uintptrType, num.Uint64(), false)
+			switch use.Opcode() {
+			case llvm.PtrToInt:
+				// Already of the correct type.
+			case llvm.BitCast:
+				// Could happen when stored in an interface (which is of type
+				// i8*).
+				typecode = llvm.ConstIntToPtr(typecode, use.Type())
+			default:
+				panic("unexpected constant expression")
+			}
+			use.ReplaceAllUsesWith(typecode)
+		}
+	}
+
+	// Only create this sidetable when it is necessary.
+	if state.needsNamedNonBasicTypesSidetable {
+		global := replaceGlobalIntWithArray(mod, "reflect.namedNonBasicTypesSidetable", state.namedNonBasicTypesSidetable)
+		global.SetLinkage(llvm.InternalLinkage)
+		global.SetUnnamedAddr(true)
+		global.SetGlobalConstant(true)
+	}
+	if state.needsArrayTypesSidetable {
+		global := replaceGlobalIntWithArray(mod, "reflect.arrayTypesSidetable", state.arrayTypesSidetable)
+		global.SetLinkage(llvm.InternalLinkage)
+		global.SetUnnamedAddr(true)
+		global.SetGlobalConstant(true)
+	}
+	if state.needsStructTypesSidetable {
+		global := replaceGlobalIntWithArray(mod, "reflect.structTypesSidetable", state.structTypesSidetable)
+		global.SetLinkage(llvm.InternalLinkage)
+		global.SetUnnamedAddr(true)
+		global.SetGlobalConstant(true)
+	}
+	if state.needsStructNamesSidetable {
+		global := replaceGlobalIntWithArray(mod, "reflect.structNamesSidetable", state.structNamesSidetable)
+		global.SetLinkage(llvm.InternalLinkage)
+		global.SetUnnamedAddr(true)
+		global.SetGlobalConstant(true)
+	}
+
+	// Remove most objects created for interface and reflect lowering.
+	// They would normally be removed anyway in later passes, but not always.
+	// It also cleans up the IR for testing.
+	for _, typ := range types {
+		initializer := typ.typecode.Initializer()
+		references := state.builder.CreateExtractValue(initializer, 0, "")
+		typ.typecode.SetInitializer(llvm.ConstNull(initializer.Type()))
+		if strings.HasPrefix(typ.name, "reflect/types.type:struct:") {
+			// Structs have a 'references' field that is not a typecode but
+			// a pointer to a runtime.structField array and therefore a
+			// bitcast. This global should be erased separately, otherwise
+			// typecode objects cannot be erased.
+			structFields := references
+			if !structFields.IsAConstantExpr().IsNil() && structFields.Opcode() == llvm.BitCast {
+				structFields = structFields.Operand(0) // get global from bitcast, for LLVM 14 compatibility (non-opaque pointers)
+			}
+			structFields.EraseFromParentAsGlobal()
+		}
+	}
+}
+
+// getTypeCodeNum returns the typecode for a given type as expected by the
+// reflect package. Also see getTypeCodeName, which serializes types to a string
+// based on a types.Type value for this function.
+func (state *typeCodeAssignmentState) getTypeCodeNum(typecode llvm.Value) *big.Int {
+	// Note: see src/reflect/type.go for bit allocations.
+	class, value := getClassAndValueFromTypeCode(typecode)
+	name := ""
+	if class == "named" {
+		name = value
+		typecode = state.builder.CreateExtractValue(typecode.Initializer(), 0, "")
+		class, value = getClassAndValueFromTypeCode(typecode)
+	}
+	if class == "basic" {
+		// Basic types follow the following bit pattern:
+		//    ...xxxxx0
+		// where xxxxx is allocated for the 18 possible basic types and all the
+		// upper bits are used to indicate the named type.
+		num, ok := basicTypes[value]
+		if !ok {
+			panic("invalid basic type: " + value)
+		}
+		if name != "" {
+			// This type is named, set the upper bits to the name ID.
+			num |= int64(state.getBasicNamedTypeNum(name)) << 5
+		}
+		return big.NewInt(num << 1)
+	} else {
+		// Non-baisc types use the following bit pattern:
+		//    ...nxxx1
+		// where xxx indicates the non-basic type. The upper bits contain
+		// whatever the type contains. Types that wrap a single other type
+		// (channel, interface, pointer, slice) just contain the bits of the
+		// wrapped type. Other types (like struct) need more fields and thus
+		// cannot be encoded as a simple prefix.
+		var classNumber int64
+		if n, ok := nonBasicTypes[class]; ok {
+			classNumber = n
+		} else {
+			panic("unknown type kind: " + class)
+		}
+		var num *big.Int
+		lowBits := (classNumber << 1) + 1 // the 5 low bits of the typecode
+		if name == "" {
+			num = state.getNonBasicTypeCode(class, typecode)
+		} else {
+			// We must return a named type here. But first check whether it
+			// has already been defined.
+			if index, ok := state.namedNonBasicTypes[name]; ok {
+				num := big.NewInt(int64(index))
+				num.Lsh(num, 5).Or(num, big.NewInt((classNumber<<1)+1+(1<<4)))
+				return num
+			}
+			lowBits |= 1 << 4 // set the 'n' bit (see above)
+			if !state.needsNamedNonBasicTypesSidetable {
+				// Use simple small integers in this case, to make these numbers
+				// smaller.
+				index := len(state.namedNonBasicTypes) + 1
+				state.namedNonBasicTypes[name] = index
+				num = big.NewInt(int64(index))
+			} else {
+				// We need to store full type information.
+				// First allocate a number in the named non-basic type
+				// sidetable.
+				index := len(state.namedNonBasicTypesSidetable)
+				state.namedNonBasicTypesSidetable = append(state.namedNonBasicTypesSidetable, 0)
+				state.namedNonBasicTypes[name] = index
+				// Get the typecode of the underlying type (which could be the
+				// element type in the case of pointers, for example).
+				num = state.getNonBasicTypeCode(class, typecode)
+				if num.BitLen() > state.uintptrLen || !num.IsUint64() {
+					panic("cannot store value in sidetable")
+				}
+				// Now update the side table with the number we just
+				// determined. We need this multi-step approach to avoid stack
+				// overflow due to adding types recursively in the case of
+				// linked lists (a pointer which points to a struct that
+				// contains that same pointer).
+				state.namedNonBasicTypesSidetable[index] = num.Uint64()
+				num = big.NewInt(int64(index))
+			}
+		}
+		// Concatenate the 'num' and 'lowBits' bitstrings.
+		num.Lsh(num, 5).Or(num, big.NewInt(lowBits))
+		return num
+	}
+}
+
+// getNonBasicTypeCode is used by getTypeCodeNum. It returns the upper bits of
+// the type code used there in the type code.
+func (state *typeCodeAssignmentState) getNonBasicTypeCode(class string, typecode llvm.Value) *big.Int {
+	switch class {
+	case "chan", "pointer", "slice":
+		// Prefix-style type kinds. The upper bits contain the element type.
+		sub := state.builder.CreateExtractValue(typecode.Initializer(), 0, "")
+		return state.getTypeCodeNum(sub)
+	case "array":
+		// An array is basically a pair of (typecode, length) stored in a
+		// sidetable.
+		return big.NewInt(int64(state.getArrayTypeNum(typecode)))
+	case "struct":
+		// More complicated type kind. The upper bits contain the index to the
+		// struct type in the struct types sidetable.
+		return big.NewInt(int64(state.getStructTypeNum(typecode)))
+	default:
+		// Type has not yet been implemented, so fall back by using a unique
+		// number.
+		num := big.NewInt(int64(state.fallbackIndex))
+		state.fallbackIndex++
+		return num
+	}
+}
+
+// getClassAndValueFromTypeCode takes a typecode (a llvm.Value of type
+// runtime.typecodeID), looks at the name, and extracts the typecode class and
+// value from it. For example, for a typecode with the following name:
+//
+//	reflect/types.type:pointer:named:reflect.ValueError
+//
+// It extracts:
+//
+//	class = "pointer"
+//	value = "named:reflect.ValueError"
+func getClassAndValueFromTypeCode(typecode llvm.Value) (class, value string) {
+	typecodeName := typecode.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:]
+	return
+}
+
+// getBasicNamedTypeNum returns an appropriate (unique) number for the given
+// named type. If the name already has a number that number is returned, else a
+// new number is returned. The number is always non-zero.
+func (state *typeCodeAssignmentState) getBasicNamedTypeNum(name string) int {
+	if num, ok := state.namedBasicTypes[name]; ok {
+		return num
+	}
+	num := len(state.namedBasicTypes) + 1
+	state.namedBasicTypes[name] = num
+	return num
+}
+
+// getArrayTypeNum returns the array type number, which is an index into the
+// reflect.arrayTypesSidetable or a unique number for this type if this table is
+// not used.
+func (state *typeCodeAssignmentState) getArrayTypeNum(typecode llvm.Value) int {
+	name := typecode.Name()
+	if num, ok := state.arrayTypes[name]; ok {
+		// This array type already has an entry in the sidetable. Don't store
+		// it twice.
+		return num
+	}
+
+	if !state.needsArrayTypesSidetable {
+		// We don't need array sidetables, so we can just assign monotonically
+		// increasing numbers to each array type.
+		num := len(state.arrayTypes)
+		state.arrayTypes[name] = num
+		return num
+	}
+
+	elemTypeCode := state.builder.CreateExtractValue(typecode.Initializer(), 0, "")
+	elemTypeNum := state.getTypeCodeNum(elemTypeCode)
+	if elemTypeNum.BitLen() > state.uintptrLen || !elemTypeNum.IsUint64() {
+		// TODO: make this a regular error
+		panic("array element type has a type code that is too big")
+	}
+
+	// The array side table is a sequence of {element type, array length}.
+	arrayLength := state.builder.CreateExtractValue(typecode.Initializer(), 1, "").ZExtValue()
+	buf := makeVarint(elemTypeNum.Uint64())
+	buf = append(buf, makeVarint(arrayLength)...)
+
+	index := len(state.arrayTypesSidetable)
+	state.arrayTypes[name] = index
+	state.arrayTypesSidetable = append(state.arrayTypesSidetable, buf...)
+	return index
+}
+
+// getStructTypeNum returns the struct type number, which is an index into
+// reflect.structTypesSidetable or an unique number for every struct if this
+// sidetable is not needed in the to-be-compiled program.
+func (state *typeCodeAssignmentState) getStructTypeNum(typecode llvm.Value) int {
+	name := typecode.Name()
+	if num, ok := state.structTypes[name]; ok {
+		// This struct already has an assigned type code.
+		return num
+	}
+
+	if !state.needsStructTypesSidetable {
+		// We don't need struct sidetables, so we can just assign monotonically
+		// increasing numbers to each struct type.
+		num := len(state.structTypes)
+		state.structTypes[name] = num
+		return num
+	}
+
+	// Get the fields this struct type contains.
+	// The struct number will be the start index of
+	structTypeGlobal := stripPointerCasts(state.builder.CreateExtractValue(typecode.Initializer(), 0, "")).Initializer()
+	numFields := structTypeGlobal.Type().ArrayLength()
+
+	// The first data that is stored in the struct sidetable is the number of
+	// fields this struct contains. This is usually just a single byte because
+	// most structs don't contain that many fields, but make it a varint just
+	// to be sure.
+	buf := makeVarint(uint64(numFields))
+
+	// Iterate over every field in the struct.
+	// Every field is stored sequentially in the struct sidetable. Fields can
+	// be retrieved from this list of fields at runtime by iterating over all
+	// of them until the right field has been found.
+	// Perhaps adding some index would speed things up, but it would also make
+	// the sidetable bigger.
+	for i := 0; i < numFields; i++ {
+		// Collect some information about this field.
+		field := state.builder.CreateExtractValue(structTypeGlobal, i, "")
+
+		nameGlobal := state.builder.CreateExtractValue(field, 1, "")
+		if nameGlobal == llvm.ConstPointerNull(nameGlobal.Type()) {
+			panic("compiler: no name for this struct field")
+		}
+		fieldNameBytes := getGlobalBytes(stripPointerCasts(nameGlobal), state.builder)
+		fieldNameNumber := state.getStructNameNumber(fieldNameBytes)
+
+		// See whether this struct field has an associated tag, and if so,
+		// store that tag in the tags sidetable.
+		tagGlobal := state.builder.CreateExtractValue(field, 2, "")
+		hasTag := false
+		tagNumber := 0
+		if tagGlobal != llvm.ConstPointerNull(tagGlobal.Type()) {
+			hasTag = true
+			tagBytes := getGlobalBytes(stripPointerCasts(tagGlobal), state.builder)
+			tagNumber = state.getStructNameNumber(tagBytes)
+		}
+
+		// The 'embedded' or 'anonymous' flag for this field.
+		embedded := state.builder.CreateExtractValue(field, 3, "").ZExtValue() != 0
+
+		// The first byte in the struct types sidetable is a flags byte with
+		// two bits in it.
+		flagsByte := byte(0)
+		if embedded {
+			flagsByte |= 1
+		}
+		if hasTag {
+			flagsByte |= 2
+		}
+		if ast.IsExported(string(fieldNameBytes)) {
+			flagsByte |= 4
+		}
+		buf = append(buf, flagsByte)
+
+		// Get the type number and add it to the buffer.
+		// All fields have a type, so include it directly here.
+		typeNum := state.getTypeCodeNum(state.builder.CreateExtractValue(field, 0, ""))
+		if typeNum.BitLen() > state.uintptrLen || !typeNum.IsUint64() {
+			// TODO: make this a regular error
+			panic("struct field has a type code that is too big")
+		}
+		buf = append(buf, makeVarint(typeNum.Uint64())...)
+
+		// Add the name.
+		buf = append(buf, makeVarint(uint64(fieldNameNumber))...)
+
+		// Add the tag, if there is one.
+		if hasTag {
+			buf = append(buf, makeVarint(uint64(tagNumber))...)
+		}
+	}
+
+	num := len(state.structTypesSidetable)
+	state.structTypes[name] = num
+	state.structTypesSidetable = append(state.structTypesSidetable, buf...)
+	return num
+}
+
+// getStructNameNumber stores this string (name or tag) onto the struct names
+// sidetable. The format is a varint of the length of the struct, followed by
+// the raw bytes of the name. Multiple identical strings are stored under the
+// same name for space efficiency.
+func (state *typeCodeAssignmentState) getStructNameNumber(nameBytes []byte) int {
+	name := string(nameBytes)
+	if n, ok := state.structNames[name]; ok {
+		// This name was used before, re-use it now (for space efficiency).
+		return n
+	}
+	// This name is not yet in the names sidetable. Add it now.
+	n := len(state.structNamesSidetable)
+	state.structNames[name] = n
+	state.structNamesSidetable = append(state.structNamesSidetable, makeVarint(uint64(len(nameBytes)))...)
+	state.structNamesSidetable = append(state.structNamesSidetable, nameBytes...)
+	return n
+}
+
+// makeVarint is a small helper function that returns the bytes of the number in
+// varint encoding.
+func makeVarint(n uint64) []byte {
+	buf := make([]byte, binary.MaxVarintLen64)
+	return buf[:binary.PutUvarint(buf, n)]
+}

transform/reflect_test.go

@@ -0,0 +1,77 @@
+package transform_test
+
+import (
+	"testing"
+
+	"github.com/tinygo-org/tinygo/transform"
+	"tinygo.org/x/go-llvm"
+)
+
+type reflectAssert struct {
+	call           llvm.Value
+	name           string
+	expectedNumber uint64
+}
+
+// Test reflect lowering. This code looks at IR like this:
+//
+//	call void @main.assertType(i32 ptrtoint (%runtime.typecodeID* @"reflect/types.type:basic:int" to i32), i8* inttoptr (i32 3 to i8*), i32 4, i8* undef, i8* undef)
+//
+// and verifies that the ptrtoint constant (the first parameter of
+// @main.assertType) is replaced with the correct type code.  The expected
+// output is this:
+//
+//	call void @main.assertType(i32 4, i8* inttoptr (i32 3 to i8*), i32 4, i8* undef, i8* undef)
+//
+// The first and third parameter are compared and must match, the second
+// parameter is ignored.
+func TestReflect(t *testing.T) {
+	t.Parallel()
+
+	mod := compileGoFileForTesting(t, "./testdata/reflect.go")
+
+	// Run the instcombine pass, to clean up the IR a bit (especially
+	// insertvalue/extractvalue instructions).
+	pm := llvm.NewPassManager()
+	defer pm.Dispose()
+	pm.AddInstructionCombiningPass()
+	pm.Run(mod)
+
+	// Get a list of all the asserts in the source code.
+	assertType := mod.NamedFunction("main.assertType")
+	var asserts []reflectAssert
+	for user := assertType.FirstUse(); !user.IsNil(); user = user.NextUse() {
+		use := user.User()
+		if use.IsACallInst().IsNil() {
+			t.Fatal("expected call use of main.assertType")
+		}
+		global := use.Operand(0).Operand(0)
+		expectedNumber := use.Operand(2).ZExtValue()
+		asserts = append(asserts, reflectAssert{
+			call:           use,
+			name:           global.Name(),
+			expectedNumber: expectedNumber,
+		})
+	}
+
+	// Sanity check to show that the test is actually testing anything.
+	if len(asserts) < 3 {
+		t.Errorf("expected at least 3 test cases, got %d", len(asserts))
+	}
+
+	// Now lower the type codes.
+	transform.LowerReflect(mod)
+
+	// Check whether the values are as expected.
+	for _, assert := range asserts {
+		actualNumberValue := assert.call.Operand(0)
+		if actualNumberValue.IsAConstantInt().IsNil() {
+			t.Errorf("expected to see a constant for %s, got something else", assert.name)
+			continue
+		}
+		actualNumber := actualNumberValue.ZExtValue()
+		if actualNumber != assert.expectedNumber {
+			t.Errorf("%s: expected number 0b%b, got 0b%b", assert.name, assert.expectedNumber, actualNumber)
+		}
+	}
+}

transform/rtcalls.go

@@ -113,6 +113,11 @@ func OptimizeReflectImplements(mod llvm.Module) {
 	builder := mod.Context().NewBuilder()
 	defer builder.Dispose()
 
+	// Get a few useful object for use later.
+	targetData := llvm.NewTargetData(mod.DataLayout())
+	defer targetData.Dispose()
+	uintptrType := mod.Context().IntType(targetData.PointerSize() * 8)
+
 	// Look up the (reflect.Value).Implements() method.
 	var implementsFunc llvm.Value
 	for fn := mod.FirstFunction(); !fn.IsNil(); fn = llvm.NextFunction(fn) {
@@ -136,13 +141,14 @@ func OptimizeReflectImplements(mod llvm.Module) {
 		}
 		interfaceType := stripPointerCasts(call.Operand(2))
 		if interfaceType.IsAGlobalVariable().IsNil() {
-			// Interface is unknown at compile time. This can't be optimized.
+			// The asserted interface is not constant, so can't optimize this
+			// code.
 			continue
 		}
 
 		if strings.HasPrefix(interfaceType.Name(), "reflect/types.type:named:") {
 			// Get the underlying type.
-			interfaceType = stripPointerCasts(builder.CreateExtractValue(interfaceType.Initializer(), 2, ""))
+			interfaceType = builder.CreateExtractValue(interfaceType.Initializer(), 0, "")
 		}
 		if !strings.HasPrefix(interfaceType.Name(), "reflect/types.type:interface:") {
 			// This is an error. The Type passed to Implements should be of
@@ -150,15 +156,16 @@ func OptimizeReflectImplements(mod llvm.Module) {
 			// reported at runtime.
 			continue
 		}
-		typeAssertFunction := mod.NamedFunction(strings.TrimPrefix(interfaceType.Name(), "reflect/types.type:") + ".$typeassert")
-		if typeAssertFunction.IsNil() {
+		if interfaceType.IsAGlobalVariable().IsNil() {
+			// Interface is unknown at compile time. This can't be optimized.
 			continue
 		}
+		typeAssertFunction := builder.CreateExtractValue(interfaceType.Initializer(), 4, "").Operand(0)
 
 		// Replace Implements call with the type assert call.
 		builder.SetInsertPointBefore(call)
 		implements := builder.CreateCall(typeAssertFunction.GlobalValueType(), typeAssertFunction, []llvm.Value{
-			call.Operand(0), // typecode to check
+			builder.CreatePtrToInt(call.Operand(0), uintptrType, ""), // typecode to check
 		}, "")
 		call.ReplaceAllUsesWith(implements)
 		call.EraseFromParentAsInstruction()