feature: ability to generate nrf firmware manifest for Open DFU format using nrf_open_dfu build tag. Intended to fix #4089

Signed-off-by: deadprogram <ron@hybridgroup.com>

.circleci/config.yml

@@ -0,0 +1,127 @@
+version: 2.1
+
+commands:
+  submodules:
+    steps:
+      - run:
+          name: "Pull submodules"
+          command: git submodule update --init
+  llvm-source-linux:
+    steps:
+      - restore_cache:
+          keys:
+            - llvm-source-19-v1
+      - run:
+          name: "Fetch LLVM source"
+          command: make llvm-source
+      - save_cache:
+          key: llvm-source-19-v1
+          paths:
+            - llvm-project/clang/lib/Headers
+            - llvm-project/clang/include
+            - llvm-project/compiler-rt
+            - llvm-project/lld/include
+            - llvm-project/llvm/include
+  hack-ninja-jobs:
+    steps:
+      - run:
+          name: "Hack Ninja to use less jobs"
+          command: |
+            echo -e '#!/bin/sh\n/usr/bin/ninja -j3 "$@"' > /go/bin/ninja
+            chmod +x /go/bin/ninja
+  build-binaryen-linux:
+    steps:
+      - restore_cache:
+          keys:
+            - binaryen-linux-v3
+      - run:
+          name: "Build Binaryen"
+          command: |
+            make binaryen
+      - save_cache:
+          key: binaryen-linux-v3
+          paths:
+            - build/wasm-opt
+  test-linux:
+    parameters:
+      llvm:
+        type: string
+      fmt-check:
+        type: boolean
+        default: true
+    steps:
+      - checkout
+      - submodules
+      - run:
+          name: "Install apt dependencies"
+          command: |
+            echo 'deb https://apt.llvm.org/bullseye/ llvm-toolchain-bullseye-<<parameters.llvm>> main' > /etc/apt/sources.list.d/llvm.list
+            wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | apt-key add -
+            apt-get update
+            apt-get install --no-install-recommends -y \
+                llvm-<<parameters.llvm>>-dev \
+                clang-<<parameters.llvm>> \
+                libclang-<<parameters.llvm>>-dev \
+                lld-<<parameters.llvm>> \
+                cmake \
+                ninja-build
+      - hack-ninja-jobs
+      - build-binaryen-linux
+      - restore_cache:
+          keys:
+            - go-cache-v4-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_PREVIOUS_BUILD_NUM }}
+            - go-cache-v4-{{ checksum "go.mod" }}
+      - llvm-source-linux
+      - run: go install -tags=llvm<<parameters.llvm>> .
+      - restore_cache:
+          keys:
+            - wasi-libc-sysroot-systemclang-v7
+      - run: make wasi-libc
+      - save_cache:
+          key: wasi-libc-sysroot-systemclang-v7
+          paths:
+            - lib/wasi-libc/sysroot
+      - when:
+          condition: <<parameters.fmt-check>>
+          steps:
+          - run:
+              # Do this before gen-device so that it doesn't check the
+              # formatting of generated files.
+              name: Check Go code formatting
+              command: make fmt-check lint
+      - run: make gen-device -j4
+      # TODO: change this to -skip='TestErrors|TestWasm' with Go 1.20
+      - run: go test -tags=llvm<<parameters.llvm>> -short -run='TestBuild|TestTest|TestGetList|TestTraceback'
+      - run: make smoketest XTENSA=0
+      - save_cache:
+          key: go-cache-v4-{{ checksum "go.mod" }}-{{ .Environment.CIRCLE_BUILD_NUM }}
+          paths:
+            - ~/.cache/go-build
+            - /go/pkg/mod
+
+jobs:
+  test-llvm15-go119:
+    docker:
+      - image: golang:1.19-bullseye
+    steps:
+      - test-linux:
+          llvm: "15"
+          # "make lint" fails before go 1.21 because internal/tools/go.mod specifies packages that require go 1.21
+          fmt-check: false
+    resource_class: large
+  test-llvm19-go123:
+    docker:
+      - image: golang:1.23-bullseye
+    steps:
+      - test-linux:
+          llvm: "19"
+    resource_class: large
+
+workflows:
+  test-all:
+    jobs:
+      # This tests our lowest supported versions of Go and LLVM, to make sure at
+      # least the smoke tests still pass.
+      - test-llvm15-go119
+      # This tests LLVM 19 support when linking against system libraries.
+      - test-llvm19-go123

.dockerignore

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

.github/workflows/build-macos.yml

@@ -16,37 +16,36 @@ jobs:
     name: build-macos
     strategy:
       matrix:
-        # macos-14: arm64 (oldest supported version as of 18-11-2025)
-        # macos-15-intel: amd64 (last intel version to be supported by github runners)
-        # See https://github.com/actions/runner-images/issues/13046
-        os: [macos-14, macos-15-intel]
+        # macos-13: amd64 (oldest supported version as of 18-10-2024)
+        # macos-14: arm64 (oldest arm64 version)
+        os: [macos-13, macos-14]
         include:
+          - os: macos-13
+            goarch: amd64
           - os: macos-14
             goarch: arm64
-          - os: macos-15-intel
-            goarch: amd64
     runs-on: ${{ matrix.os }}
     steps:
       - name: Install Dependencies
         run: |
           HOMEBREW_NO_AUTO_UPDATE=1 brew install qemu binaryen
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
         with:
           submodules: true
       - name: Extract TinyGo version
         id: version
         run: ./.github/workflows/tinygo-extract-version.sh | tee -a "$GITHUB_OUTPUT"
       - name: Install Go
-        uses: actions/setup-go@v6
+        uses: actions/setup-go@v5
         with:
-          go-version: '1.27.0'
+          go-version: '1.23'
           cache: true
       - name: Restore LLVM source cache
-        uses: actions/cache/restore@v5
+        uses: actions/cache/restore@v4
         id: cache-llvm-source
         with:
-          key: llvm-source-22-${{ matrix.os }}-v1
+          key: llvm-source-19-${{ matrix.os }}-v1
           path: |
             llvm-project/clang/lib/Headers
             llvm-project/clang/include
@@ -57,7 +56,7 @@ jobs:
         if: steps.cache-llvm-source.outputs.cache-hit != 'true'
         run: make llvm-source
       - name: Save LLVM source cache
-        uses: actions/cache/save@v5
+        uses: actions/cache/save@v4
         if: steps.cache-llvm-source.outputs.cache-hit != 'true'
         with:
           key: ${{ steps.cache-llvm-source.outputs.cache-primary-key }}
@@ -68,10 +67,10 @@ jobs:
             llvm-project/lld/include
             llvm-project/llvm/include
       - name: Restore LLVM build cache
-        uses: actions/cache/restore@v5
+        uses: actions/cache/restore@v4
         id: cache-llvm-build
         with:
-          key: llvm-build-22-${{ matrix.os }}-v1
+          key: llvm-build-19-${{ matrix.os }}-v1
           path: llvm-build
       - name: Build LLVM
         if: steps.cache-llvm-build.outputs.cache-hit != 'true'
@@ -80,20 +79,29 @@ jobs:
           rm -rf llvm-project
           make llvm-source
           # install dependencies
-          HOMEBREW_NO_AUTO_UPDATE=1 brew install ninja
+          HOMEBREW_NO_AUTO_UPDATE=1 brew install cmake ninja
           # build!
           make llvm-build
           find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
       - name: Save LLVM build cache
-        uses: actions/cache/save@v5
+        uses: actions/cache/save@v4
         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@v4
+        id: cache-wasi-libc
+        with:
+          key: wasi-libc-sysroot-${{ matrix.os }}-v1
+          path: lib/wasi-libc/sysroot
+      - name: Build wasi-libc
+        if: steps.cache-wasi-libc.outputs.cache-hit != 'true'
+        run: make wasi-libc
       - name: make gen-device
         run: make -j3 gen-device
       - name: Test TinyGo
-        run: make test GOTESTFLAGS="-only-current-os"
+        run: make test GOTESTFLAGS="-short"
       - name: Build TinyGo release tarball
         run: make release -j3
       - name: Test stdlib packages
@@ -101,22 +109,27 @@ jobs:
       - name: Make release artifact
         run: cp -p build/release.tar.gz build/tinygo${{ steps.version.outputs.version }}.darwin-${{ matrix.goarch }}.tar.gz
       - name: Publish release artifact
-        uses: actions/upload-artifact@v7
+        # Note: this release artifact is double-zipped, see:
+        # https://github.com/actions/upload-artifact/issues/39
+        # We can essentially pick one of these:
+        # - have a double-zipped artifact when downloaded from the UI
+        # - have a very slow artifact upload
+        # We're doing the former here, to keep artifact uploads fast.
+        uses: actions/upload-artifact@v4
         with:
           name: darwin-${{ matrix.goarch }}-double-zipped-${{ steps.version.outputs.version }}
           path: build/tinygo${{ steps.version.outputs.version }}.darwin-${{ matrix.goarch }}.tar.gz
-          archive: false
       - name: Smoke tests
-        run: make smoketest-quick TINYGO=$(PWD)/build/tinygo
+        run: make smoketest TINYGO=$(PWD)/build/tinygo
   test-macos-homebrew:
     name: homebrew-install
     runs-on: macos-latest
     strategy:
       matrix:
-        version: [16, 17, 18, 19, 20]
+        version: [16, 17, 18, 19]
     steps:
       - name: Set up Homebrew
-        uses: Homebrew/actions/setup-homebrew@main
+        uses: Homebrew/actions/setup-homebrew@master
       - name: Fix Python symlinks
         run: |
           # Github runners have broken symlinks, so relink
@@ -125,21 +138,20 @@ jobs:
       - name: Install LLVM
         run: |
           brew install llvm@${{ matrix.version }}
-          brew link llvm@${{ matrix.version }}
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
       - name: Install Go
-        uses: actions/setup-go@v6
+        uses: actions/setup-go@v5
         with:
-          go-version: '1.27.0'
+          go-version: '1.23'
           cache: true
       - name: Build TinyGo (LLVM ${{ matrix.version }})
         run: go install -tags=llvm${{ matrix.version }}
       - name: Check binary
         run: tinygo version
       - name: Build TinyGo (default LLVM)
-        if: matrix.version == 20
+        if: matrix.version == 19
         run: go install
       - name: Check binary
-        if: matrix.version == 20
+        if: matrix.version == 19
         run: tinygo version

.github/workflows/compat.yml

@@ -1,72 +0,0 @@
-# This CI job checks whether at least the smoke tests pass for the oldest
-# Go/LLVM version we claim to support.
-
-name: Version compatibility test
-
-on:
-  pull_request:
-  push:
-    branches:
-      - dev
-      - release
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  test-compat:
-    runs-on: ubuntu-22.04 # this must be a specific version for the apt install below
-    env:
-      # Oldest versions currently supported by TinyGo
-      LLVM: "15"
-      Go: "1.25" # when updating this, also update minorMin in builder/config.go
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-        with:
-          submodules: true
-      - name: Install Go
-        uses: actions/setup-go@v6
-        with:
-          go-version: ${{ env.Go }}
-          cache: true
-      - name: Install LLVM
-        run: |
-          echo 'deb https://apt.llvm.org/jammy/ llvm-toolchain-jammy-${{ env.LLVM }} main' | sudo tee /etc/apt/sources.list.d/llvm.list
-          wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
-          sudo apt-get update
-          sudo apt-get install --no-install-recommends -y \
-              llvm-${{ env.LLVM }}-dev \
-              clang-${{ env.LLVM }} \
-              libclang-${{ env.LLVM }}-dev \
-              lld-${{ env.LLVM }} \
-              binaryen
-      - name: Restore LLVM source cache
-        uses: actions/cache/restore@v5
-        id: cache-llvm-source
-        with:
-          key: llvm-source-22-linux-compat
-          path: llvm-project/compiler-rt
-      - 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@v5
-        if: steps.cache-llvm-source.outputs.cache-hit != 'true'
-        with:
-          key: ${{ steps.cache-llvm-source.outputs.cache-primary-key }}
-          path: llvm-project/compiler-rt
-      - name: Go cache
-        uses: actions/cache@v5
-        with:
-          path: |
-            ~/.cache/go-build
-            ~/go/pkg/mod
-          key: go-build-${{ env.Go }}-llvm${{ env.LLVM }}-${{ hashFiles('go.sum') }}
-      - name: Build TinyGo
-        run: go install -tags=llvm${{ env.LLVM }}
-      - run: tinygo version
-      - run: make gen-device -j4
-      - run: go test -tags=llvm${{ env.LLVM }} -short -skip=TestErrors
-      - run: make smoketest-quick XTENSA=0

.github/workflows/docker.yml

@@ -31,14 +31,14 @@ jobs:
           sudo rm -rf /usr/local/share/boost
           df -h
       - name: Check out the repo
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
         with:
           submodules: recursive
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v4
+        uses: docker/setup-buildx-action@v3
       - name: Docker meta
         id: meta
-        uses: docker/metadata-action@v6
+        uses: docker/metadata-action@v5
         with:
           images: |
             tinygo/tinygo-dev
@@ -47,18 +47,18 @@ jobs:
             type=sha,format=long
             type=raw,value=latest
       - name: Log in to Docker Hub
-        uses: docker/login-action@v4
+        uses: docker/login-action@v3
         with:
           username: ${{ secrets.DOCKER_HUB_USERNAME }}
           password: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}
       - name: Log in to Github Container Registry
-        uses: docker/login-action@v4
+        uses: docker/login-action@v3
         with:
           registry: ghcr.io
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
       - name: Build and push
-        uses: docker/build-push-action@v7
+        uses: docker/build-push-action@v5
         with:
           context: .
           push: true
@@ -66,3 +66,45 @@ jobs:
           labels: ${{ steps.meta.outputs.labels }}
           cache-from: type=gha
           cache-to: type=gha,mode=max
+      - name: Trigger Drivers 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/drivers/actions/workflows/build.yml/dispatches \
+          -d '{"ref": "dev"}'
+      - name: Trigger Bluetooth repo build on Github Actions
+        run: |
+          curl -X POST \
+          -H "Authorization: Bearer ${{secrets.GHA_ACCESS_TOKEN}}" \
+          -H "Accept: application/vnd.github.v3+json" \
+          https://api.github.com/repos/tinygo-org/bluetooth/actions/workflows/linux.yml/dispatches \
+          -d '{"ref": "dev"}'
+      - name: Trigger TinyFS repo build on 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/tinyfs/actions/workflows/build.yml/dispatches \
+          -d '{"ref": "dev"}'
+      - name: Trigger TinyFont 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/tinyfont/actions/workflows/build.yml/dispatches \
+          -d '{"ref": "dev"}'
+      - name: Trigger TinyDraw 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/tinydraw/actions/workflows/build.yml/dispatches \
+          -d '{"ref": "dev"}'
+      - name: Trigger TinyTerm repo build on Github Actions
+        run: |
+          curl -X POST \
+          -H "Authorization: Bearer ${{secrets.GHA_ACCESS_TOKEN}}" \
+          -H "Accept: application/vnd.github.v3+json" \
+          https://api.github.com/repos/tinygo-org/tinyterm/actions/workflows/build.yml/dispatches \
+          -d '{"ref": "dev"}'

.github/workflows/extract-changelog.sh

@@ -1,35 +0,0 @@
-#!/bin/sh
-
-# Print the CHANGELOG.md entry for one version, to use as release notes.
-# The file uses a setext heading: the bare version, then a line of dashes.
-
-set -e
-
-version="$1"
-if [ -z "$version" ]; then
-	echo "usage: $0 <version>" >&2
-	exit 1
-fi
-
-notes=$(awk -v version="$version" '
-	found {
-		if ($0 ~ /^---+$/ && previous != "") { previous = ""; exit }
-		if (previous != "") print previous
-		previous = $0
-		next
-	}
-	$0 ~ /^---+$/ && previous == version {
-		found = 1
-		previous = ""
-		next
-	}
-	{ previous = $0 }
-	END { if (found && previous != "") print previous }
-' CHANGELOG.md)
-
-if [ -z "$notes" ]; then
-	echo "no CHANGELOG.md entry for version $version" >&2
-	exit 1
-fi
-
-echo "$notes"

.github/workflows/linux.yml

@@ -12,61 +12,43 @@ concurrency:
   cancel-in-progress: true
 
 jobs:
-  go-mod-tidy:
-    # Check that go.sum is up to date.
-    runs-on: ubuntu-slim
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-        with:
-          submodules: true
-      - name: Install Go
-        uses: actions/setup-go@v6
-        with:
-          go-version: '1.27.0'
-          cache: true
-      - name: Run go mod tidy
-        run: go mod tidy
-      - name: Check go.mod and go.sum are up to date
-        run: git diff --exit-code
-
   build-linux:
     # Build Linux binaries, ready for release.
     # This runs inside an Alpine Linux container so we can more easily create a
     # statically linked binary.
     runs-on: ubuntu-latest
     container:
-      image: golang:1.27-alpine
+      image: golang:1.23-alpine
     outputs:
       version: ${{ steps.version.outputs.version }}
     steps:
       - name: Install apk dependencies
-        # tar: needed for actions/cache@v5
+        # tar: needed for actions/cache@v4
         # git+openssh: needed for checkout (I think?)
         # ruby: needed to install fpm
-        run: apk add tar git openssh make g++ ruby-dev mold
+        run: apk add tar git openssh make g++ ruby-dev
       - name: Work around CVE-2022-24765
         # We're not on a multi-user machine, so this is safe.
         run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
         with:
           submodules: true
       - name: Extract TinyGo version
         id: version
         run: ./.github/workflows/tinygo-extract-version.sh | tee -a "$GITHUB_OUTPUT"
       - name: Cache Go
-        uses: actions/cache@v5
+        uses: actions/cache@v4
         with:
-          key: go-cache-linux-alpine-v2-${{ hashFiles('go.mod') }}
+          key: go-cache-linux-alpine-v1-${{ hashFiles('go.mod') }}
           path: |
             ~/.cache/go-build
             ~/go/pkg/mod
       - name: Restore LLVM source cache
-        uses: actions/cache/restore@v5
+        uses: actions/cache/restore@v4
         id: cache-llvm-source
         with:
-          key: llvm-source-22-linux-alpine-v1
+          key: llvm-source-19-linux-alpine-v1
           path: |
             llvm-project/clang/lib/Headers
             llvm-project/clang/include
@@ -77,7 +59,7 @@ jobs:
         if: steps.cache-llvm-source.outputs.cache-hit != 'true'
         run: make llvm-source
       - name: Save LLVM source cache
-        uses: actions/cache/save@v5
+        uses: actions/cache/save@v4
         if: steps.cache-llvm-source.outputs.cache-hit != 'true'
         with:
           key: ${{ steps.cache-llvm-source.outputs.cache-primary-key }}
@@ -88,10 +70,10 @@ jobs:
             llvm-project/lld/include
             llvm-project/llvm/include
       - name: Restore LLVM build cache
-        uses: actions/cache/restore@v5
+        uses: actions/cache/restore@v4
         id: cache-llvm-build
         with:
-          key: llvm-build-22-linux-alpine-v1
+          key: llvm-build-19-linux-alpine-v1
           path: llvm-build
       - name: Build LLVM
         if: steps.cache-llvm-build.outputs.cache-hit != 'true'
@@ -106,22 +88,31 @@ jobs:
           # Remove unnecessary object files (to reduce cache size).
           find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
       - name: Save LLVM build cache
-        uses: actions/cache/save@v5
+        uses: actions/cache/save@v4
         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@v5
+        uses: actions/cache@v4
         id: cache-binaryen
         with:
-          key: binaryen-linux-alpine-v3
+          key: binaryen-linux-alpine-v1
           path: build/wasm-opt
       - name: Build Binaryen
         if: steps.cache-binaryen.outputs.cache-hit != 'true'
         run: |
           apk add cmake samurai python3
           make binaryen STATIC=1
+      - name: Cache wasi-libc
+        uses: actions/cache@v4
+        id: cache-wasi-libc
+        with:
+          key: wasi-libc-sysroot-linux-alpine-v2
+          path: lib/wasi-libc/sysroot
+      - name: Build wasi-libc
+        if: steps.cache-wasi-libc.outputs.cache-hit != 'true'
+        run: make wasi-libc
       - name: Install fpm
         run: |
           gem install --version 4.0.7 public_suffix
@@ -136,31 +127,26 @@ jobs:
           make release deb -j3 STATIC=1
           cp -p build/release.tar.gz /tmp/tinygo${{ steps.version.outputs.version }}.linux-amd64.tar.gz
           cp -p build/release.deb    /tmp/tinygo_${{ steps.version.outputs.version }}_amd64.deb
-      - name: "Publish release artifact: tarball"
-        uses: actions/upload-artifact@v7
+      - name: Publish release artifact
+        uses: actions/upload-artifact@v4
         with:
-          name: tinygo${{ steps.version.outputs.version }}.linux-amd64.tar.gz
-          path: /tmp/tinygo${{ steps.version.outputs.version }}.linux-amd64.tar.gz
-          archive: false
-      - name: "Publish release artifact: Debian package"
-        uses: actions/upload-artifact@v7
-        with:
-          name: tinygo_${{ steps.version.outputs.version }}_amd64.deb
-          path: /tmp/tinygo_${{ steps.version.outputs.version }}_amd64.deb
-          archive: false
+          name: linux-amd64-double-zipped-${{ steps.version.outputs.version }}
+          path: |
+            /tmp/tinygo${{ steps.version.outputs.version }}.linux-amd64.tar.gz
+            /tmp/tinygo_${{ steps.version.outputs.version }}_amd64.deb
   test-linux-build:
     # Test the binaries built in the build-linux job by running the smoke tests.
     runs-on: ubuntu-latest
     needs: build-linux
     steps:
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
         with:
           submodules: true
       - name: Install Go
-        uses: actions/setup-go@v6
+        uses: actions/setup-go@v5
         with:
-          go-version: '1.27.0'
+          go-version: '1.23'
           cache: true
       - name: Install wasmtime
         uses: bytecodealliance/actions/wasmtime/setup@v1
@@ -169,9 +155,9 @@ jobs:
       - name: Install wasm-tools
         uses: bytecodealliance/actions/wasm-tools/setup@v1
       - name: Download release artifact
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@v4
         with:
-          name: tinygo${{ needs.build-linux.outputs.version }}.linux-amd64.tar.gz
+          name: linux-amd64-double-zipped-${{ needs.build-linux.outputs.version }}
       - name: Extract release tarball
         run: |
           mkdir -p ~/lib
@@ -179,51 +165,14 @@ jobs:
           ln -s ~/lib/tinygo/bin/tinygo ~/go/bin/tinygo
       - run: make tinygo-test-wasip1-fast
       - run: make tinygo-test-wasip2-fast
-      - run: make tinygo-test-wasm
-  smoketest-linux:
-    # Build a binary for every supported board, using the binaries built in the
-    # build-linux job. This is the only job that runs the full smoke test. The
-    # result does not depend on the host OS, so the other jobs build a
-    # representative board for each architecture with smoketest-quick.
-    runs-on: ubuntu-latest
-    needs: build-linux
-    strategy:
-      fail-fast: false
-      matrix:
-        # Balanced with the measured build time of each group, so that the
-        # shards finish at about the same time.
-        group:
-          - smoketest-rp2xxx smoketest-selftest smoketest-wasm-sim smoketest-py32
-          - smoketest-esp smoketest-riscv smoketest-flags
-          - smoketest-examples smoketest-nxp smoketest-pwm-usb smoketest-avr
-          - smoketest-samd smoketest-stm32 smoketest-nrf smoketest-wasm
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-        with:
-          submodules: true
-      - name: Install Go
-        uses: actions/setup-go@v6
-        with:
-          go-version: '1.27.0'
-          cache: true
-      - name: Download release artifact
-        uses: actions/download-artifact@v8
-        with:
-          name: tinygo${{ needs.build-linux.outputs.version }}.linux-amd64.tar.gz
-      - name: Extract release tarball
-        run: |
-          mkdir -p ~/lib
-          tar -C ~/lib -xf tinygo${{ needs.build-linux.outputs.version }}.linux-amd64.tar.gz
-          ln -s ~/lib/tinygo/bin/tinygo ~/go/bin/tinygo
-      - run: make testchdir ${{ matrix.group }}
+      - run: make smoketest
   assert-test-linux:
     # Run all tests that can run on Linux, with LLVM assertions enabled to catch
     # potential bugs.
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
         with:
           submodules: true
       - name: Install apt dependencies
@@ -232,43 +181,31 @@ jobs:
           cat /proc/cpuinfo
           sudo apt-get update
           sudo apt-get install --no-install-recommends \
-              libgcrypt20 \
-              libpixman-1-0 \
-              libsdl2-2.0-0 \
-              libslirp0 \
               qemu-system-arm \
               qemu-system-riscv32 \
               qemu-user \
               simavr \
               ninja-build
       - name: Install Go
-        uses: actions/setup-go@v6
+        uses: actions/setup-go@v5
         with:
-          go-version: '1.27.0'
+          go-version: '1.23'
           cache: true
       - name: Install Node.js
-        uses: actions/setup-node@v6
+        uses: actions/setup-node@v4
         with:
-          node-version: '22'
+          node-version: '18'
       - name: Install wasmtime
         uses: bytecodealliance/actions/wasmtime/setup@v1
         with:
           version: "29.0.1"
       - name: Setup `wasm-tools`
         uses: bytecodealliance/actions/wasm-tools/setup@v1
-      - name: Install Espressif QEMU
-        run: |
-          release=esp-develop-9.2.2-20260417
-          archive=qemu-xtensa-softmmu-${release//-/_}-x86_64-linux-gnu.tar.xz
-          curl -fL --retry 3 -o "$RUNNER_TEMP/$archive" \
-            "https://github.com/espressif/qemu/releases/download/$release/$archive"
-          tar -xJf "$RUNNER_TEMP/$archive" -C "$RUNNER_TEMP"
-          echo "$RUNNER_TEMP/qemu/bin" >> "$GITHUB_PATH"
       - name: Restore LLVM source cache
-        uses: actions/cache/restore@v5
+        uses: actions/cache/restore@v4
         id: cache-llvm-source
         with:
-          key: llvm-source-22-linux-asserts-v1
+          key: llvm-source-19-linux-asserts-v1
           path: |
             llvm-project/clang/lib/Headers
             llvm-project/clang/include
@@ -279,7 +216,7 @@ jobs:
         if: steps.cache-llvm-source.outputs.cache-hit != 'true'
         run: make llvm-source
       - name: Save LLVM source cache
-        uses: actions/cache/save@v5
+        uses: actions/cache/save@v4
         if: steps.cache-llvm-source.outputs.cache-hit != 'true'
         with:
           key: ${{ steps.cache-llvm-source.outputs.cache-primary-key }}
@@ -290,10 +227,10 @@ jobs:
             llvm-project/lld/include
             llvm-project/llvm/include
       - name: Restore LLVM build cache
-        uses: actions/cache/restore@v5
+        uses: actions/cache/restore@v4
         id: cache-llvm-build
         with:
-          key: llvm-build-22-linux-asserts-v1
+          key: llvm-build-19-linux-asserts-v1
           path: llvm-build
       - name: Build LLVM
         if: steps.cache-llvm-build.outputs.cache-hit != 'true'
@@ -306,13 +243,13 @@ jobs:
           # Remove unnecessary object files (to reduce cache size).
           find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
       - name: Save LLVM build cache
-        uses: actions/cache/save@v5
+        uses: actions/cache/save@v4
         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@v5
+        uses: actions/cache@v4
         id: cache-binaryen
         with:
           key: binaryen-linux-asserts-v1
@@ -320,6 +257,15 @@ jobs:
       - name: Build Binaryen
         if: steps.cache-binaryen.outputs.cache-hit != 'true'
         run: make binaryen
+      - name: Cache wasi-libc
+        uses: actions/cache@v4
+        id: cache-wasi-libc
+        with:
+          key: wasi-libc-sysroot-linux-asserts-v6
+          path: lib/wasi-libc/sysroot
+      - name: Build wasi-libc
+        if: steps.cache-wasi-libc.outputs.cache-hit != 'true'
+        run: make wasi-libc
       - run: make gen-device -j4
       - name: Test TinyGo
         run: make ASSERT=1 test
@@ -329,11 +275,9 @@ jobs:
           echo "$(pwd)/build" >> $GITHUB_PATH
       - name: Test stdlib packages
         run: make tinygo-test
-      - run: make smoketest-quick
+      - run: make smoketest
       - run: make wasmtest
-      - run: make tinygo-test-baremetal
-      - name: Check Go code formatting
-        run: make fmt-check lint
+      - run: make tinygo-baremetal
   build-linux-cross:
     # Build ARM Linux binaries, ready for release.
     # This intentionally uses an older Linux image, so that we compile against
@@ -353,11 +297,11 @@ jobs:
           - goarch: arm
             toolchain: arm-linux-gnueabihf
             libc: armhf
-    runs-on: ubuntu-22.04 # note: use the oldest image available! (see above)
+    runs-on: ubuntu-latest
     needs: build-linux
     steps:
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
       - name: Get TinyGo version
         id: version
         run: ./.github/workflows/tinygo-extract-version.sh | tee -a "$GITHUB_OUTPUT"
@@ -369,15 +313,15 @@ jobs:
               g++-${{ matrix.toolchain }} \
               libc6-dev-${{ matrix.libc }}-cross
       - name: Install Go
-        uses: actions/setup-go@v6
+        uses: actions/setup-go@v5
         with:
-          go-version: '1.27.0'
+          go-version: '1.23'
           cache: true
       - name: Restore LLVM source cache
-        uses: actions/cache/restore@v5
+        uses: actions/cache/restore@v4
         id: cache-llvm-source
         with:
-          key: llvm-source-22-linux-v1
+          key: llvm-source-19-linux-v1
           path: |
             llvm-project/clang/lib/Headers
             llvm-project/clang/include
@@ -388,7 +332,7 @@ jobs:
         if: steps.cache-llvm-source.outputs.cache-hit != 'true'
         run: make llvm-source
       - name: Save LLVM source cache
-        uses: actions/cache/save@v5
+        uses: actions/cache/save@v4
         if: steps.cache-llvm-source.outputs.cache-hit != 'true'
         with:
           key: ${{ steps.cache-llvm-source.outputs.cache-primary-key }}
@@ -399,10 +343,10 @@ jobs:
             llvm-project/lld/include
             llvm-project/llvm/include
       - name: Restore LLVM build cache
-        uses: actions/cache/restore@v5
+        uses: actions/cache/restore@v4
         id: cache-llvm-build
         with:
-          key: llvm-build-22-linux-${{ matrix.goarch }}-v1
+          key: llvm-build-19-linux-${{ matrix.goarch }}-v2
           path: llvm-build
       - name: Build LLVM
         if: steps.cache-llvm-build.outputs.cache-hit != 'true'
@@ -417,16 +361,16 @@ jobs:
           # Remove unnecessary object files (to reduce cache size).
           find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
       - name: Save LLVM build cache
-        uses: actions/cache/save@v5
+        uses: actions/cache/save@v4
         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@v5
+        uses: actions/cache@v4
         id: cache-binaryen
         with:
-          key: binaryen-linux-${{ matrix.goarch }}-v5
+          key: binaryen-linux-${{ matrix.goarch }}-v4
           path: build/wasm-opt
       - name: Build Binaryen
         if: steps.cache-binaryen.outputs.cache-hit != 'true'
@@ -443,9 +387,9 @@ jobs:
         run: |
           make CROSS=${{ matrix.toolchain }}
       - name: Download amd64 release
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@v4
         with:
-          name: tinygo${{ needs.build-linux.outputs.version }}.linux-amd64.tar.gz
+          name: linux-amd64-double-zipped-${{ needs.build-linux.outputs.version }}
       - name: Extract amd64 release
         run: |
           mkdir -p build/release
@@ -457,17 +401,12 @@ jobs:
       - name: Create ${{ matrix.goarch }} release
         run: |
           make release deb RELEASEONLY=1 DEB_ARCH=${{ matrix.libc }}
-          cp -p build/release.tar.gz /tmp/tinygo${{ needs.build-linux.outputs.version }}.linux-${{ matrix.goarch }}.tar.gz
-          cp -p build/release.deb    /tmp/tinygo_${{ needs.build-linux.outputs.version }}_${{ matrix.libc }}.deb
-      - name: "Publish release artifact: tarball"
-        uses: actions/upload-artifact@v7
+          cp -p build/release.tar.gz /tmp/tinygo${{ steps.version.outputs.version }}.linux-${{ matrix.goarch }}.tar.gz
+          cp -p build/release.deb    /tmp/tinygo_${{ steps.version.outputs.version }}_${{ matrix.libc }}.deb
+      - name: Publish release artifact
+        uses: actions/upload-artifact@v4
         with:
-          name: linux-${{ matrix.goarch }}-double-zipped-${{ needs.build-linux.outputs.version }}
-          path: /tmp/tinygo${{ needs.build-linux.outputs.version }}.linux-${{ matrix.goarch }}.tar.gz
-          archive: false
-      - name: "Publish release artifact: Debian package"
-        uses: actions/upload-artifact@v7
-        with:
-          name: linux-${{ matrix.goarch }}-double-zipped-${{ needs.build-linux.outputs.version }}
-          path: /tmp/tinygo_${{ needs.build-linux.outputs.version }}_${{ matrix.libc }}.deb
-          archive: false
+          name: linux-${{ matrix.goarch }}-double-zipped-${{ steps.version.outputs.version }}
+          path: |
+            /tmp/tinygo${{ steps.version.outputs.version }}.linux-${{ matrix.goarch }}.tar.gz
+            /tmp/tinygo_${{ steps.version.outputs.version }}_${{ matrix.libc }}.deb

.github/workflows/llvm.yml

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

.github/workflows/nix.yml

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

.github/workflows/release.yml

@@ -1,158 +0,0 @@
-# Publish a GitHub release from the artifacts that CI already built.
-#
-# The Linux, macOS and Windows workflows build every file that a release needs
-# when the release branch is pushed. This workflow collects the artifacts of
-# those runs for the tagged commit, so what ships is what was tested.
-#
-# The release is a draft, so the notes can be reviewed before publication.
-name: Release
-
-on:
-  push:
-    tags:
-      - 'v*'
-  workflow_dispatch:
-    inputs:
-      tag:
-        description: 'Tag to release, for example v0.42.0'
-        required: true
-
-concurrency:
-  group: release-${{ inputs.tag || github.ref_name }}
-  cancel-in-progress: false
-
-permissions:
-  contents: write
-  actions: read
-
-jobs:
-  release:
-    runs-on: ubuntu-latest
-    env:
-      GH_TOKEN: ${{ github.token }}
-      GH_REPO: ${{ github.repository }}
-      TAG: ${{ inputs.tag || github.ref_name }}
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-        with:
-          ref: ${{ inputs.tag || github.ref_name }}
-          fetch-depth: 0
-      - name: Read the version
-        id: version
-        # The release file names come from goenv/version.go, not from the tag,
-        # so the two must agree.
-        run: |
-          version=$(./.github/workflows/tinygo-extract-version.sh | cut -d= -f2-)
-          case "$version" in
-            *-dev)
-              echo "::error::goenv/version.go has development version $version"
-              exit 1
-              ;;
-          esac
-          if [ "v$version" != "$TAG" ]; then
-            echo "::error::tag $TAG does not match version $version in goenv/version.go"
-            exit 1
-          fi
-          echo "version=$version" >> "$GITHUB_OUTPUT"
-      - name: Wait for the CI runs of this commit
-        id: runs
-        # A pull request run has the merge commit as its head, so look at push
-        # runs only.
-        run: |
-          sha=$(git rev-parse HEAD)
-          for workflow in linux.yml build-macos.yml windows.yml; do
-            id=
-            for _ in $(seq 20); do
-              id=$(gh run list --workflow "$workflow" --commit "$sha" --event push --limit 1 --json databaseId --jq '.[0].databaseId')
-              if [ -n "$id" ]; then
-                break
-              fi
-              echo "waiting for $workflow to start on $sha"
-              sleep 30
-            done
-            if [ -z "$id" ]; then
-              echo "::error::no $workflow run for commit $sha"
-              exit 1
-            fi
-            echo "$workflow: run $id"
-            gh run watch "$id" --exit-status > /dev/null || true
-            conclusion=$(gh run view "$id" --json conclusion --jq .conclusion)
-            if [ "$conclusion" != "success" ]; then
-              echo "::error::$workflow run $id concluded with $conclusion"
-              exit 1
-            fi
-            case "$workflow" in
-              linux.yml)       echo "linux=$id"   >> "$GITHUB_OUTPUT" ;;
-              build-macos.yml) echo "macos=$id"   >> "$GITHUB_OUTPUT" ;;
-              windows.yml)     echo "windows=$id" >> "$GITHUB_OUTPUT" ;;
-            esac
-          done
-      # The build jobs upload with `archive: false`, so the artifact is the
-      # release file itself. skip-decompress keeps it that way. The Windows
-      # release is a .zip, which a download would otherwise unpack.
-      - name: Download the Linux artifacts
-        uses: actions/download-artifact@v8
-        with:
-          run-id: ${{ steps.runs.outputs.linux }}
-          github-token: ${{ github.token }}
-          path: artifacts
-          skip-decompress: true
-      - name: Download the macOS artifacts
-        uses: actions/download-artifact@v8
-        with:
-          run-id: ${{ steps.runs.outputs.macos }}
-          github-token: ${{ github.token }}
-          path: artifacts
-          skip-decompress: true
-      - name: Download the Windows artifacts
-        uses: actions/download-artifact@v8
-        with:
-          run-id: ${{ steps.runs.outputs.windows }}
-          github-token: ${{ github.token }}
-          path: artifacts
-          skip-decompress: true
-      - name: Collect the release files
-        # A build that stopped uploading must not give a half complete release,
-        # so list the files that are expected. The search is by file name, not
-        # by artifact name, because the artifact names are not uniform.
-        env:
-          VERSION: ${{ steps.version.outputs.version }}
-        run: |
-          version=$VERSION
-          mkdir -p dist
-          missing=0
-          for file in \
-              "tinygo$version.linux-amd64.tar.gz"  "tinygo_${version}_amd64.deb" \
-              "tinygo$version.linux-arm.tar.gz"    "tinygo_${version}_armhf.deb" \
-              "tinygo$version.linux-arm64.tar.gz"  "tinygo_${version}_arm64.deb" \
-              "tinygo$version.darwin-amd64.tar.gz" \
-              "tinygo$version.darwin-arm64.tar.gz" \
-              "tinygo$version.windows-amd64.zip"; do
-            found=$(find artifacts -type f -name "$file" | head -1)
-            if [ -z "$found" ]; then
-              echo "::error::missing release file $file"
-              missing=1
-            else
-              mv "$found" "dist/$file"
-            fi
-          done
-          ls -l dist
-          exit $missing
-      - name: Extract the release notes
-        env:
-          VERSION: ${{ steps.version.outputs.version }}
-        run: ./.github/workflows/extract-changelog.sh "$VERSION" > notes.md
-      - name: Create the draft release
-        env:
-          VERSION: ${{ steps.version.outputs.version }}
-        run: |
-          version=$VERSION
-          set --
-          case "$version" in
-            *-*) set -- --prerelease ;;
-          esac
-          gh release create "$TAG" --draft --verify-tag "$@" \
-            --title "$version" \
-            --notes-file notes.md \
-            dist/*

.github/workflows/sizediff-install-pkgs.sh

@@ -2,11 +2,11 @@
 # still works after checking out the dev branch (that is, when going from LLVM
 # 16 to LLVM 17 for example, both Clang 16 and Clang 17 are installed).
 
-echo 'deb https://apt.llvm.org/noble/ llvm-toolchain-noble-20 main' | sudo tee /etc/apt/sources.list.d/llvm.list
+echo 'deb https://apt.llvm.org/noble/ llvm-toolchain-noble-19 main' | sudo tee /etc/apt/sources.list.d/llvm.list
 wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
 sudo apt-get update
 sudo apt-get install --no-install-recommends -y \
-    llvm-20-dev \
-    clang-20 \
-    libclang-20-dev \
-    lld-20
+    llvm-19-dev \
+    clang-19 \
+    libclang-19-dev \
+    lld-19

.github/workflows/sizediff.yml

@@ -19,29 +19,25 @@ jobs:
       - name: Add GOBIN to $PATH
         run: |
           echo "$HOME/go/bin" >> $GITHUB_PATH
-      - name: Install Go
-        uses: actions/setup-go@v6
-        with:
-          go-version: '~1.25'
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0 # fetch all history (no sparse checkout)
           submodules: true
       - name: Install apt dependencies
         run: ./.github/workflows/sizediff-install-pkgs.sh
       - name: Restore LLVM source cache
-        uses: actions/cache@v5
+        uses: actions/cache@v4
         id: cache-llvm-source
         with:
-          key: llvm-source-22-sizediff-v1
+          key: llvm-source-19-sizediff-v1
           path: |
             llvm-project/compiler-rt
       - name: Download LLVM source
         if: steps.cache-llvm-source.outputs.cache-hit != 'true'
         run: make llvm-source
       - name: Cache Go
-        uses: actions/cache@v5
+        uses: actions/cache@v4
         with:
           key: go-cache-linux-sizediff-v2-${{ hashFiles('go.mod') }}
           path: |

.github/workflows/windows.yml

@@ -17,14 +17,21 @@ jobs:
     outputs:
       version: ${{ steps.version.outputs.version }}
     steps:
-      - uses: MinoruSekine/setup-scoop@v4
+      - name: Configure pagefile
+        uses: al-cheb/configure-pagefile-action@v1.4
+        with:
+          minimum-size: 8GB
+          maximum-size: 24GB
+          disk-root: "C:"
+      - uses: brechtm/setup-scoop@v2
+        with:
+          scoop_update: 'false'
       - name: Install Dependencies
         shell: bash
         run: |
-          scoop config use_external_7zip true
           scoop install ninja binaryen
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
         with:
           submodules: true
       - name: Extract TinyGo version
@@ -32,15 +39,15 @@ jobs:
         shell: bash
         run: ./.github/workflows/tinygo-extract-version.sh | tee -a "$GITHUB_OUTPUT"
       - name: Install Go
-        uses: actions/setup-go@v6
+        uses: actions/setup-go@v5
         with:
-          go-version: '1.27.0'
+          go-version: '1.23'
           cache: true
       - name: Restore cached LLVM source
-        uses: actions/cache/restore@v5
+        uses: actions/cache/restore@v4
         id: cache-llvm-source
         with:
-          key: llvm-source-22-windows-v3
+          key: llvm-source-19-windows-v1
           path: |
             llvm-project/clang/lib/Headers
             llvm-project/clang/include
@@ -51,7 +58,7 @@ jobs:
         if: steps.cache-llvm-source.outputs.cache-hit != 'true'
         run: make llvm-source
       - name: Save cached LLVM source
-        uses: actions/cache/save@v5
+        uses: actions/cache/save@v4
         if: steps.cache-llvm-source.outputs.cache-hit != 'true'
         with:
           key: ${{ steps.cache-llvm-source.outputs.cache-primary-key }}
@@ -62,10 +69,10 @@ jobs:
             llvm-project/lld/include
             llvm-project/llvm/include
       - name: Restore cached LLVM build
-        uses: actions/cache/restore@v5
+        uses: actions/cache/restore@v4
         id: cache-llvm-build
         with:
-          key: llvm-build-22-windows-v1
+          key: llvm-build-19-windows-v1
           path: llvm-build
       - name: Build LLVM
         if: steps.cache-llvm-build.outputs.cache-hit != 'true'
@@ -79,27 +86,35 @@ jobs:
           # Remove unnecessary object files (to reduce cache size).
           find llvm-build -name CMakeFiles -prune -exec rm -r '{}' \;
       - name: Save cached LLVM build
-        uses: actions/cache/save@v5
+        uses: actions/cache/save@v4
         if: steps.cache-llvm-build.outputs.cache-hit != 'true'
         with:
           key: ${{ steps.cache-llvm-build.outputs.cache-primary-key }}
           path: llvm-build
-      - name: Cache Go cache
-        uses: actions/cache@v5
+      - name: Cache wasi-libc sysroot
+        uses: actions/cache@v4
+        id: cache-wasi-libc
         with:
-          key: go-cache-windows-v3-${{ hashFiles('go.mod') }}
+          key: wasi-libc-sysroot-v5
+          path: lib/wasi-libc/sysroot
+      - name: Build wasi-libc
+        if: steps.cache-wasi-libc.outputs.cache-hit != 'true'
+        run: make wasi-libc
+      - name: Cache Go cache
+        uses: actions/cache@v4
+        with:
+          key: go-cache-windows-v1-${{ hashFiles('go.mod') }}
           path: |
             C:/Users/runneradmin/AppData/Local/go-build
             C:/Users/runneradmin/go/pkg/mod
       - name: Install wasmtime
         run: |
-          scoop config use_external_7zip true
           scoop install wasmtime@29.0.1
       - name: make gen-device
         run: make -j3 gen-device
       - name: Test TinyGo
         shell: bash
-        run: make test GOTESTFLAGS="-only-current-os"
+        run: make test GOTESTFLAGS="-short"
       - name: Build TinyGo release tarball
         shell: bash
         run: make build/release -j4
@@ -108,56 +123,80 @@ jobs:
         working-directory: build/release
         run: 7z -tzip a tinygo${{ steps.version.outputs.version }}.windows-amd64.zip tinygo
       - name: Publish release artifact
-        uses: actions/upload-artifact@v7
+        # Note: this release artifact is double-zipped, see:
+        # https://github.com/actions/upload-artifact/issues/39
+        # We can essentially pick one of these:
+        # - have a dobule-zipped artifact when downloaded from the UI
+        # - have a very slow artifact upload
+        # We're doing the former here, to keep artifact uploads fast.
+        uses: actions/upload-artifact@v4
         with:
-          name: tinygo${{ steps.version.outputs.version }}.windows-amd64.zip
+          name: windows-amd64-double-zipped-${{ steps.version.outputs.version }}
           path: build/release/tinygo${{ steps.version.outputs.version }}.windows-amd64.zip
-          archive: false
 
   smoke-test-windows:
     runs-on: windows-2022
     needs: build-windows
     steps:
-      - uses: MinoruSekine/setup-scoop@v4
+      - name: Configure pagefile
+        uses: al-cheb/configure-pagefile-action@v1.4
+        with:
+          minimum-size: 8GB
+          maximum-size: 24GB
+          disk-root: "C:"
+      - uses: brechtm/setup-scoop@v2
+        with:
+          scoop_update: 'false'
       - name: Install Dependencies
         shell: bash
         run: |
-          scoop config use_external_7zip true
           scoop install binaryen
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
       - name: Install Go
-        uses: actions/setup-go@v6
+        uses: actions/setup-go@v5
         with:
-          go-version: '1.27.0'
+          go-version: '1.23'
           cache: true
       - name: Download TinyGo build
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@v4
         with:
-          name: tinygo${{ needs.build-windows.outputs.version }}.windows-amd64.zip
+          name: windows-amd64-double-zipped-${{ needs.build-windows.outputs.version }}
           path: build/
-        # This build is already unzipped.
+      - name: Unzip TinyGo build
+        shell: bash
+        working-directory: build
+        run: 7z x tinygo*.windows-amd64.zip -r
       - name: Smoke tests
         shell: bash
-        run: make smoketest-quick TINYGO=$(PWD)/build/tinygo/bin/tinygo
+        run: make smoketest TINYGO=$(PWD)/build/tinygo/bin/tinygo
 
   stdlib-test-windows:
     runs-on: windows-2022
     needs: build-windows
     steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-      - name: Install Go
-        uses: actions/setup-go@v6
+      - name: Configure pagefile
+        uses: al-cheb/configure-pagefile-action@v1.4
         with:
-          go-version: '1.27.0'
+          minimum-size: 8GB
+          maximum-size: 24GB
+          disk-root: "C:"
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Install Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: '1.23'
           cache: true
       - name: Download TinyGo build
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@v4
         with:
-          name: tinygo${{ needs.build-windows.outputs.version }}.windows-amd64.zip
+          name: windows-amd64-double-zipped-${{ needs.build-windows.outputs.version }}
           path: build/
-        # This build is already unzipped.
+      - name: Unzip TinyGo build
+        shell: bash
+        working-directory: build
+        run: 7z x tinygo*.windows-amd64.zip -r
       - name: Test stdlib packages
         run: make tinygo-test TINYGO=$(PWD)/build/tinygo/bin/tinygo
 
@@ -165,24 +204,34 @@ jobs:
     runs-on: windows-2022
     needs: build-windows
     steps:
-      - uses: MinoruSekine/setup-scoop@v4
+      - name: Configure pagefile
+        uses: al-cheb/configure-pagefile-action@v1.4
+        with:
+          minimum-size: 8GB
+          maximum-size: 24GB
+          disk-root: "C:"
+      - uses: brechtm/setup-scoop@v2
+        with:
+          scoop_update: 'false'
       - name: Install Dependencies
         shell: bash
         run: |
-          scoop config use_external_7zip true
-          scoop install binaryen wasmtime@29.0.1
+          scoop install binaryen && scoop install wasmtime@29.0.1
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
       - name: Install Go
-        uses: actions/setup-go@v6
+        uses: actions/setup-go@v5
         with:
-          go-version: '1.27.0'
+          go-version: '1.23'
           cache: true
       - name: Download TinyGo build
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@v4
         with:
-          name: tinygo${{ needs.build-windows.outputs.version }}.windows-amd64.zip
+          name: windows-amd64-double-zipped-${{ needs.build-windows.outputs.version }}
           path: build/
-        # This build is already unzipped.
+      - name: Unzip TinyGo build
+        shell: bash
+        working-directory: build
+        run: 7z x tinygo*.windows-amd64.zip -r
       - name: Test stdlib packages on wasip1
         run: make tinygo-test-wasip1-fast TINYGO=$(PWD)/build/tinygo/bin/tinygo

.gitignore

@@ -24,8 +24,6 @@ src/device/renesas/*.go
 src/device/renesas/*.s
 src/device/rp/*.go
 src/device/rp/*.s
-src/device/py32/*.go
-src/device/py32/*.s
 ./vendor
 llvm-build
 llvm-project

.gitmodules

@@ -16,13 +16,13 @@
 	url = https://github.com/WebAssembly/wasi-libc
 [submodule "lib/picolibc"]
 	path = lib/picolibc
-	url = https://github.com/picolibc/picolibc.git
+	url = https://github.com/keith-packard/picolibc.git
 [submodule "lib/stm32-svd"]
 	path = lib/stm32-svd
 	url = https://github.com/tinygo-org/stm32-svd
 [submodule "lib/musl"]
 	path = lib/musl
-	url = https://github.com/tinygo-org/musl-libc.git
+	url = git://git.musl-libc.org/musl
 [submodule "lib/binaryen"]
 	path = lib/binaryen
 	url = https://github.com/WebAssembly/binaryen.git
@@ -35,12 +35,7 @@
 [submodule "src/net"]
 	path = src/net
 	url = https://github.com/tinygo-org/net.git
+	branch = dev
 [submodule "lib/wasi-cli"]
 	path = lib/wasi-cli
 	url = https://github.com/WebAssembly/wasi-cli
-[submodule "lib/bdwgc"]
-	path = lib/bdwgc
-	url = https://github.com/ivmai/bdwgc.git
-[submodule "lib/py32-svd"]
-	path = lib/py32-svd
-	url = https://github.com/tinygo-org/py32-svd.git

AGENTS.md

@@ -1,10 +0,0 @@
-## Communication style
-Use ASD-STE-100 Simplified Technical English when you speak to the operator.
-
-## Comments
-Use ASD-STE100 Simplified Technical English for content outside of the code like comments, PR description, PR title, github comments, and issues.
-
-Generally omit extra redundant comments. If a comment is absolutely needed, always keep it brief, no more than 2 lines. Avoid extra use of colons, semicolons, and dashes. When comments are required due to some specific requirements, include a reference such as to a datasheet or other definitive source to explain why this is the case, including the chapter/section number, page number, and/or URL.
-
-## No coding tool attributions
-Never add "created by XXX" or any other attributions from coding tools to any PRs, issues, comments, or anywhere else.

BUILDING.md

@@ -30,10 +30,7 @@ on a different system like Mac.
 
 ## Using GNU Make
 
-The static build of TinyGo is driven by GNUmakefile, which includes the topic
-files in the `make/` directory (`config.mk`, `llvm.mk`, `gen-device.mk`,
-`build.mk`, `test.mk`, `smoketest.mk`, `release.mk`, and `tools.mk`).
-It provides a help target for quick reference:
+The static build of TinyGo is driven by GNUmakefile, which provides a help target for quick reference:
 
     % make help
     clean                           Remove build directory
@@ -67,7 +64,7 @@ while producing binaries that are about as fast.
     export CC=clang
     export CXX=clang++
 
-`make/config.mk` holds a default configuration that is good for most users. It
+The Makefile includes a default configuration that is good for most users. It
 builds a release version of LLVM (optimized, no asserts) and includes all
 targets supported by TinyGo:
 
@@ -88,17 +85,11 @@ Try running TinyGo:
 
     ./build/tinygo help
 
-Also, make sure the `tinygo` binary really is statically linked. The command to check for 
-dynamic dependencies differs depending on your operating system.
-
-On Linux, use `ldd` (not to be confused with `lld`):
+Also, make sure the `tinygo` binary really is statically linked. Check this
+using `ldd` (not to be confused with `lld`):
 
     ldd ./build/tinygo
 
-On macOS, use otool -L:
-
-    otool -L ./build/tinygo
-
 The result should not contain libclang or libLLVM.
 
 ## Make a release tarball
@@ -119,35 +110,3 @@ the following command (for example in ~/lib):
 TinyGo will get extracted to a `tinygo` directory. You can then call it with:
 
     ./tinygo/bin/tinygo
-
-## Publish a release
-
-The `Release` workflow (`.github/workflows/release.yml`) publishes releases. It
-does not build anything. The Linux, macOS and Windows workflows already build
-every file that a release needs when the `release` branch is pushed, so the
-release workflow collects the artifacts of those runs for the tagged commit.
-What ships is what was tested.
-
- 1. On the `dev` branch, set `const version` in `goenv/version.go` to the new
-    version (without a `v` prefix), and add the entry to `CHANGELOG.md`.
- 2. Merge `dev` into the `release` branch.
- 3. Tag that commit and push the tag:
-
-        git tag v0.42.0
-        git push origin v0.42.0
-
-    The tag must be `v` plus the version in `goenv/version.go`, because the
-    release file names come from that constant.
- 4. The workflow waits for the Linux, macOS and Windows runs of the tagged
-    commit, collects their nine files, and creates a **draft** release. The
-    release notes come from the `CHANGELOG.md` entry for that version.
- 5. Review the draft release and publish it.
- 6. On the `dev` branch, set `goenv/version.go` to the next `-dev` version.
-
-To release again after a failure, delete the draft release and start the
-workflow from the Actions tab with the tag as its input.
-
-GitHub keeps a SHA-256 digest of every published file. The digest is not shown
-on the release page, but it can be printed with:
-
-    gh release view v0.42.0 --json assets --jq '.assets[] | "\(.digest)  \(.name)"'

CHANGELOG.md

@@ -1,530 +1,3 @@
-0.41.1
----
-* **machine**
-  - esp32c3: correct pin interrupt setup call that was overlooked from #5320
-* **runtime**
-  - esp32s3: wait for TIMG0 update register to clear before reading timer registers
-* **net**
-  - update net module to a version that is backwards compatible with Go 1.25.x to fix #5332
-
-0.41.0
----
-* **general**
-  - go.mod, compiler: bump minimum Go version to 1.23
-  - builder: support Go 1.26 now
-  - feat: add inheritable-only field to filter processor-level targets (#5270)
-  - feature: add esp32flash flash method for esp32s3/esp32c3/esp32/esp8266
-  - flashing: introduce flash method 'esp32jtag' for esp32c3/esp32s3 targets
-  - fashing: add "adb" flash method using Android Debug Bridge
-  - main: auto-use best available flashing options on esp32
-  - espflasher: update to espflasher 0.6.0
-* **compiler**
-  - implement method-set based AssignableTo and Implements (#5304)
-  - simplify createObjectLayout
-  - implement copy directly
-  - fix min/max on floats by using intrinsics
-  - add element layout to sliceAppend
-  - add intrinsic for crypto/internal/constanttime.boolToUint8
-  - fix SyscallN handling for Windows on Go 1.26+
-* **core**
-  - reflect: add TypeAssert
-  - reflect: fix TypeAssert for structs
-  - sync: add WaitGroup.Go
-  - os: add UserCacheDir and UserConfigDir
-  - os: implement Lchown function for changing file ownership (#5161)
-  - testing: add b.ReportMetric()
-  - errors: add errors package to passing list
-  - internal/gclayout: use correct lengths
-  - internal/abi: add EscapeNonString, EscapeToResultNonString
-  - internal, runtime: add internal fips bool
-  - internal/itoa: resurrect from Go stdlib
-  - internal/syscall/unix: implement GetRandom for WASI targets
-  - interp: make ptrtoint size mismatch a recoverable error
-  - loader: support "all:" prefix in //go:embed patterns
-  - loader, crypto/internal/entropy: fix 32 MiB RAM overflow on microcontrollers
-  - loader, unicode/utf8: fix hiBits overflow on 16-bit AVR targets
-  - builder: order embedded files deterministically
-  - builder: fix panic in findPackagePath when using -size short
-  - builder: fix SIGSEGV when stripping duplicate function definitions
-  - builder, runtime: fix duplicate symbol error with Go 1.26+ on Windows
-  - builder: use target-specific -march for RISC-V library compilation
-  - transform: modify output format from the -print-allocs flag to match the go coverage tool format
-  - cgo: allow for changes to 'short-enums' flag
-  - wasm: add more stubbed file operations
-* **machine**
-  - esp32c3: implement BlockDevice for esp32c3 flash
-  - esp32c3: clear GPIO STATUS before dispatching pin callbacks
-  - esp32c3: implement USBDevice using interrupts
-  - esp32c3: add Enable stub for QEMU test target
-  - esp32c3: fix interrupt disable handling
-  - esp32c3: clear MCAUSE after handling interrupt
-  - esp32c3: map missing IRAM sections in linker script
-  - esp32c3: fix to use PROVIDE() for WiFi/BLE ROM function addresses to allow blob overrides
-  - esp32c3: add WiFi/BLE ROM linker support
-  - esp32c3: use TIMG0 alarm interrupt for sleepTicks instead of busy-waiting
-  - esp32s3: implement Pin.SetInterrupt for GPIO pin change interrupts
-  - esp32s3: use edge-triggered CPU interrupt for GPIO pin interrupts
-  - esp32s3: add interrupt support (#5244)
-  - esp32s3: switch USB implementation to use interrupts instead of polling
-  - esp32s3: replace inline ISR with full interrupt vector handler
-  - esp32s3: use TIMG0 alarm interrupt for sleepTicks
-  - esp32s3: improve exception handlers, add procPin/procUnpin, and linker wrap flags
-  - esp32s3: fix Xtensa register window spill using recursive call4 in task switching
-  - esp32s3: update linker script and boot assembly for multi-page flash XIP mapping
-  - esp32s3: add flash XIP boot assembly with cache/MMU init
-  - esp32s3: implement SPI (#5169)
-  - esp32s3: implement I2C interface (#5210)
-  - esp32s3: implement RNG based on onboard hardware random number generator
-  - esp32s3,esp32c3: add USB serial support
-  - esp32s3,esp32c3: add txStalled flag to skip USB serial spin when no host
-  - esp32s3,esp32c3: make USB Serial/JTAG writes non-blocking when FIFO is full
-  - esp32c3/esp32s3: refactor ADC implementation to reduce code duplication
-  - esp32s3,esp32c3: add ADC support (#5231)
-  - esp32s3,esp32c3: add PWM support (#5215)
-  - esp32c3/esp32s3: refactoring and corrections for SPI implementation
-  - esp32xx: add WASM simulator support for ESP32-C3/ESP32-S3 targets
-  - esp32: default SPI CS pin to NoPin when unset
-  - esp: fix tinygo_scanCurrentStack to spill register windows
-  - stm32: fix UART interrupt storm caused by uncleared overrun error
-  - stm32: fix PWM problem due to register shifting
-  - stm32: add STM32U585 target definition and runtime
-  - stm32: add STM32U5 GPIO, pin interrupts, and UART support
-  - stm32: add STM32U5 I2C support
-  - stm32: add STM32U5 SPI support
-  - stm32u585: implement ADC
-  - stm32g0b1: add support (#5150)
-  - stm32g0b1: add Watchdog + ADC support (#5158)
-  - stm32l0: add flash support
-  - stm32l0x1,l0x2: TIM: adapt to 32-bit register access
-  - stm32g0: sync with updated stm32 device files
-  - attiny85: add USI-based SPI support (#5181)
-  - attiny85: add PWM support (#5171)
-  - rp: add Close function to UART to allow for removing all system resources/power usage
-  - rp: use blockReset() and unresetBlockWait() helper functions for peripheral reset/unreset
-  - rp2: prevent PWM Period method overflow
-  - rp2: add per-byte timeout budget for I2C (#5189)
-  - feather-m0: export UART0 and pins
-  - usb/cdc: better ring buffer implementation (#5209)
-  - fix: replace ! with ~ for register mask
-  - atmega328p_simulator: add correct build tag for arduino_uno after renaming
-* **net**
-  - update to Go 1.26.2 net package with UDP and JS improvements
-* **runtime**
-  - implement fminimum/fmaximum
-  - make timeoffset atomic
-  - add MemStats.HeapObjects
-  - handle GODEBUG on wasip2 (#5312)
-  - fix Darwin syscall return value truncation and lost arguments
-  - add syscall.runtimeClearenv for Go 1.26
-  - split syscall functions for darwin changes for 1.26
-  - fix: init heap before random number seed on wasm platforms
-* **targets**
-  - add esp32s3-supermini board target
-  - add support for Seeedstudio Xiao-RP2350 board
-  - add Shrike Lite board (#5170)
-  - rename arduino target to arduino-uno
-  - add pins/setup for Arduino UNO Q board QWIIC connector
-  - correct pin mapping for Arduino UNO Q STM32 MCU
-  - add stm32u585 openocd commands for flashing on Arduino UNO Q
-  - correct name/tag use for esp32s3-wroom1 board
-  - modify esp32, esp32s3, esp32c3, & esp8266 targets to use built-in esp32flash
-  - switch rp2040/rp2350 to default to tasks scheduler
-  - change default stack size for esp32c3 and esp32s3 to 8196
-  - swan: rename group build tag stm32l4x5 => stm32l4y5 to avoid clash with stm32 device name
-  - nucleo-f722ze: add build-tag stm32f722
-  - fix: set stm32u5x clock rate to default
-  - create generic targets for esp32 boards
-* **libs**
-  - stm32-svd: update submodule
-  - update tools/gen-device-svd for recent changes to stm32-svd file structure (#5212)
-* **build/test**
-  - build: use Golang 1.26 for all builds
-  - build: actually use the version of llvm we are supposed to be testing by using brew link command
-  - build: let scoop run updates to resolve binaryen install failures on Windows
-  - ci: don't double zip release artifacts
-  - test: increase default timeout from 1 to 2 minutes to prevent spurious CI fails
-  - testdata: fix flaky timers test by draining ticker channel after Stop
-  - testdata: more corpus entries (#5182)
-  - add soypat/lneto to corpus
-  - GNUmakefile: add context and expvar to stdlib tests
-  - GNUmakefile: add encoding/xml to stdlib tests on Linux
-  - main (test): skip mipsle test if the emulator is missing
-  - make: remove machine without board from smoketest
-  - stm32: add Arduino UNO Q to smoketests
-  - flake: bump to nixpkgs 25.11
-  - chore: update all github actions to latest versions
-  - fix: use external 7zip for scoop installs on Windows
-
-0.40.1
----
-* **machine**
-  - nrf: fix flash writes when SoftDevice is enabled
-* **runtime**
-  - runtime: avoid fixed math/rand sequence on RP2040/RP2350 (#5124)
-  - runtime: add calls to initRand() during run() for all schedulers
-  - runtime: call initRand() before initHeap() during initialization
-  - runtime: use rand_hwrng hardwareRand for RP2040/RP2350 (#5135)
-* **libs**
-  - picolibc: use updated location for git repo
-
-0.40.0
----
-* **general**
-  - all: add full LLVM 20 support
-  - core: feat: enable //go:linkname pragma for globals
-  - core: feature: Add flag to ignore go compatibility matrix (#5078)
-  - chore: update version for 0.40 development cycle
-* **compiler**
-  - emit an error when the actual arch doesn't match GOARCH
-  - mark string parameters as readonly
-  - use Tarjan's SCC algorithm to detect loops for defer
-  - lower "large stack" limit to 16kb
-* **core**
-  - shrink bdwgc library
-  - Fix linker errors for runtime.vgetrandom and crypto/internal/sysrand.fatal
-  - fix: add TryLock to sync.RWMutex
-  - fix: correct linter issues exposed by the fix in #4679
-  - fix: don't hardcode success return state
-  - fix: expand RTT debugger compatibility
-  - internal/task (threads): save stack bounds instead of scanning under a lock
-  - internal/task: create detached threads and fix error handling
-  - interp: better errors when debugging interp
-  - transform (gc): create stack slots in callers of external functions
-  - internal/task: prevent semaphore resource leak for threads scheduler
-* **machine**
-  - cortexm: optimize code size for the HardFault_Handler
-  - fe310: add I2C pins for the HiFive1b
-  - clarify WriteAt semantics of BlockDevice
-  - fix deprecated AsmFull comment (#5005)
-  - make sure DMA buffers do not escape unnecessarily
-  - only enable USB-CDC when needed
-  - use larger SPI MAXCNT on nrf52833 and nrf52840
-  - fix: update m.queuedBytes when clamping output to avoid corrupting sentBytes
-  - fix: use int64 in ReadTemperature to avoid overflow
-  - fix(rp2): disable DBGPAUSE on startup
-  - fix(rp2): possible integer overflow while computing factors for SPI baudrate
-  - fix(rp2): reset spinlocks at startup
-  - fix(rp2): switch spinlock busy loop to wfe
-  - fix(rp2): use side-effect-free spinlocks
-  - nrf: add ADC_VDDH which is an ADC pin for VDDH
-  - nrf: don't block SPI transfer
-  - nrf: don't set PSELN, it's ignored in single ended mode anyway
-  - nrf: fix typo in ADC configuration
-  - nrf: refactor SoftDevice enabled check
-  - nrf: rename pwmPin to adcPin
-  - nrf: support flash operations while the SoftDevice is enabled
-  - rp2040: allow writing to the UART inside interrupts
-  - machine,nrf528: stop the bus only once on I2C bus error and ensures the first error is returned
-* **net**
-  - update submodule to latest commits
-* **runtime**
-  - (avr): fix infinite longjmp loop if stack is aligned to 256 bytes
-  - (gc_blocks.go): clear full size of allocation
-  - (gc_blocks.go): make sweep branchless
-  - (gc_blocks.go): simplify scanning logic
-  - (gc_blocks.go): use a linked stack to scan marked objects
-  - (gc_blocks.go): use best-fit allocation
-  - (gc_boehm.go): fix world already stopped check
-  - (wasm): scan the system stack
-  - fix sleep duration for long sleeps
-  - remove copied code for nrf52840
-  - src/syscall: update src buffer after write
-  - wasm: fix C realloc and optimize it a bit
-* **targets**
-  - add xiao-esp32s3 board target
-  - Add ESP32-S3 support (#5091)
-  - Added Gopher ARCADE board
-  - Create "pico2-ice" target board (#5062)
-* **build/test**
-  - Add testing.T.Context() and testing.B.Context()
-  - create separate go.mod file for testing dependencies for wasm tests that use Chromium headless browser to avoid use of older incompatible version.
-  - go back to normal scheduler instead of tasks scheduler for macos CI
-  - update CI to use Go 1.25.5
-  - update macOS GH actions builds to handle sunset of macOS 13
-  - use task scheduler on macOS builds to avoid test race condition lockups
-  - update all CI builds to use latest stable Go release. Also update some of the actions to their latest releases.
-  - update GH actions builds to use Go 1.25.4
-  - uninstall cmake before install
-  - fix: point the submodule for musl-lib to a mirror in the TinyGo GitHub org
-  - fix: remove macOS 15 from CI build matrix (conflicts with macOS 14 build)
-  - fix: separate host expected bytes from device intended bytes
-  - fix/typo: makeESPFirmwareImage
-  - make: GNUmakefile: shrink TinyGo binaries on Linux
-  - move the directory list into a variable
-  - several improvements to the macOS GH actions build
-  - Fix for #4678: top-level 'make lint' wasn't working
-  - fix: increase the timeout for chromedp to connect to the headless browser used for running the wasm tests.
-  - testdata: some more packages for the test corpus
-
-0.39.0
----
-* **general**
-  - all: add Go 1.25 support
-  - net: update to latest tinygo net package
-  - docs: clarify build verification step for macOS users
-  - Add flag to skip Renesas SVD builds
-* **build**
-  - Makefile: install missing dlmalloc files
-  - flash: add -o flag support to save built binary (Fixes #4937) (#4942)
-  - fix: update version of clang to 17 to accommodate latest Go 1.25 docker base image
-* **ci**
-  - chore: update all CI builds to test Go 1.25 release
-  - fix: disable test-newest since CircleCI seems unable to download due to rate-limits on Dockerhub
-  - ci: rename some jobs to avoid churn on every Go/LLVM version bump
-  - ci: make the goroutines test less racy
-  - tests: de-flake goroutines test
-* **compiler**
-  - compiler: implement internal/abi.Escape
-* **main**
-  - main: show the compiler error (if any) for `tinygo test -c`
-  - chore: correct GOOS=js name in error messages for WASM
-* **machine**
-  - machine: add international keys
-  - machine: remove some unnecessary "// peripherals:" comments
-  - machine: add I2C pin comments
-  - machine: standardize I2C errors with "i2c:" prefix
-  - machine: make I2C usable in the simulator
-  - fix: add SPI and I2C to teensy 4.1 (#4943)
-  - `rp2`: use the correct channel mask for rp2350 ADC; hold lock during read (#4938)
-  - `rp2`: disable digital input for analog inputs
-* **runtime**
-  - runtime: ensure time.Sleep(d) sleeps at least d
-  - runtime: stub out weak pointer support
-  - runtime: implement dummy AddCleanup
-  - runtime: enable multi-core scheduler for rp2350
-  - `internal/task`: use -stack-size flag when starting a new thread
-  - `internal/task`: add SA_RESTART flag to GC interrupts
-  - `internal/task`: a few small correctness fixes
-  - `internal/gclayout`: make gclayout values constants
-  - darwin: add threading support and use it by default
-* **standard library**
-  - `sync`: implement sync.Swap
-  - `reflect`: implement Method.IsExported
-* **testing**
-  - testing: stub out testing.B.Loop
-* **targets**
-  - `stm32`: add support for the STM32L031G6U6
-  - add metro-rp2350 board definition (#4989)
-  - `rp2040/rp2350`: set the default stack size to 8k for rp2040/rp2350 based boards where this was not already the case
-
-
-0.38.0
----
-* **general**
-  - `go.*`: upgrade `golang.org/x/tools` to v0.30.0
-  - `all`: add support for LLVM 20
-* **build**
-  - go back to using MinoruSekine/setup-scoop for Windows CI builds
-  - `flake.*`: upgrade to nixpkgs 25.05, LLVM 20
-  - `Makefile`: only detect ccache command when needed
-  - `Makefile`: create random filename inside rule
-  - `Makefile`: don't set GOROOT
-  - `Makefile`: call uname at most once
-  - `Makefile`: only read NodeJS version when it is needed
-* **compiler**
-  - add support for `GODEBUG=gotypesalias=1`
-  - `interp`: fix `copy()` from/to external buffers
-  - add `-nobounds` (similar to `-gcflags=-B`)
-  - `compileopts`: add library version to cached library path
-  - `builder`: build wasi-libc inside TinyGo
-  - `builder`: simplify bdwgc libc dependency
-  - `builder`: don't use precompiled libraries
-  - `compileopts`: enable support for `GOARCH=wasm` in `tinygo test`
-* **fixes**
-  - `rp2350`: Fix DMA to SPI transmits on RP2350 (#4903)
-  - `microbit v2`: use OpenOCD flash method on microbit v2 when using Nordic Semi SoftDevice
-  - `main`: display all of the current GC options for the `-gc` flag
-  - Remove duplicated error handling
-  - `sync`: fix `TestMutexConcurrent` test
-  - fix race condition in `testdata/goroutines.go`
-  - fix build warnings on Windows ARM
-* **machine**
-  - `usb`: add USB mass storage class support
-  - implement usb receive message throttling
-  - declare usb endpoints per-platform
-  - `samd21`: implement watchdog
-  - `samd51`: write to flash memory in 512 byte long chunks
-  - `samd21`: write to flash memory in 64 byte long chunks
-  - don't inline RTT `WriteByte` everywhere
-  - `rp2`: unexport machine-specific errors
-  - `rp2`: discount scheduling delays in I2C timeouts (#4876)
-  - use pointer receiver in simulated PWM peripherals
-  - add simulated PWM/timer peripherals
-  - `rp2`: expose usb endpoint stall handling
-  - `arm`: clear pending interrupts before enabling them
-  - `rp2`: merge common usb code (#4856)
-* **main**
-  - add "cores" and "threads" schedulers to help text
-  - add `StartPos` and `EndPos` to `-json` build output
-  - change `-json` flag to match upstream Go
-* **runtime**
-  - don't lock the print output inside interrupts
-  - don't try to interrupt other cores before they are started
-  - implement `NumCPU` for the multicore scheduler
-  - add support for multicore scheduler
-  - refactor obtaining the system stack
-  - `interrupt`: add `Checkpoint` type
-  - add `exportedFuncPtr`
-  - avoid an allocation in `(*time.Timer).Reset`
-  - stub runtime signal functions for `os/signal` on wasip1
-  - move `timeUnit` to a single place
-  - implement `NumCPU` for `-scheduler=threads`
-  - move `mainExited` boolean
-  - `internal/task`: rename `tinygo_pause` to `tinygo_task_exit`
-  - map every goroutine to a new OS thread
-  - refactor `timerQueue`
-  - make conservative and precise GC MT-safe
-  - `internal/task`: implement atomic primitives for preemptive scheduling
-  - Use diskutil on macOS to extract volume name and path for FAT mounts #4928
-* **standard library**
-  - `net`: update submodule to latest commits
-  - `runtime/debug`: add GC related stubs
-  - `metrics`: flesh out some of the metric types
-  - `reflect`: Chan related stubs
-  - `os`: handle relative and abs paths in `Executable()`
-  - `os`: add `os.Executable()` for Darwin
-  - `sync`: implement `RWMutex` using futexes
-  - `reflect`: Add `SliceOf`, `ArrayOf`, `StructOf`, `MapOf`, `FuncOf`
-* **targets**
-  - `rp2040`: add multicore support
-  - `riscv32`: use `gdb` binary as a fallback
-  - add target for Microbit v2 with SoftDevice S140 support for both peripheral and central
-  - `windows`: use MSVCRT.DLL instead of UCRT on i386
-  - `windows`: add windows/386 support
-  - `arm64`: remove unnecessary `.section` directive
-  - `riscv-qemu`: actually sleep in `time.Sleep()`
-  - `riscv`: define CSR constants and use them where possible
-  - `darwin`: support Boehm GC (and use by default)
-  - `windows`: add support for the Boehm-Demers-Weiser GC
-  - `windows`: fix wrong register for first parameter
-* **wasm**
-  - add Boehm GC support
-  - refactor/modify stub signal handling
-  - don't block `//go:wasmexport` because of running goroutines
-  - use `int64` instead of `float64` for the `timeUnit`
-* **boards**
-  - Add board support for BigTreeTech SKR Pico (#4842)
-
-
-0.37.0
----
-* **general**
-  - add the Boehm-Demers-Weiser GC on Linux
-* **ci**
-  - add more tests for wasm and baremetal
-* **compiler**
-  - crypto/internal/sysrand is allowed to use unsafe signatures
-* **examples**
-  - add goroutine benchmark to examples
-* **fixes**
-  - ensure use of pointers for SPI interface on atsam21/atsam51 and other machines/boards that were missing implementation (#4798)
-  - replace loop counter with hw timer for USB SetAddressReq on rp2040 (#4796)
-* **internal**
-  - update to go.bytecodealliance.org@v0.6.2 in GNUmakefile and internal/wasm-tools
-  - exclude certain files when copying package in internal/cm
-  - update to go.bytecodealliance.org/cm@v0.2.2 in internal/cm
-  - remove old reflect.go in internal/reflectlite
-* **loader**
-  - use build tags for package iter and iter methods on reflect.Value in loader, iter, reflect
-  - add shim for go1.22 and earlier in loader, iter
-* **machine**
-  - bump rp2040 to 200MHz (#4768)
-  - correct register address for Pin.SetInterrupt for rp2350 (#4782)
-  - don't block the rp2xxx UART interrupt handler
-  - fix RP2040 Pico board on the playground
-  - add flash support for rp2350 (#4803)
-* **os**
-  - add stub Symlink for wasm
-* **refactor**
-  - use *SPI everywhere to make consistent for implementations. Fixes #4663 "in reverse" by making SPI a pointer everywhere, as discussed in the comments.
-* **reflect**
-  - add Value.SetIter{Key,Value} and MapIter.Reset in reflect, internal/reflectlite
-  - embed reflectlite types into reflect types in reflect, internal/reflectlite
-  - add Go 1.24 iter.Seq[2] methods
-  - copy reflect iter tests from upstream Go
-  - panic on Type.CanSeq[2] instead of returning false
-  - remove strconv.go
-  - remove unused go:linkname functions
-* **riscv-qemu**
-  - add VirtIO RNG device
-  - increase stack size
-* **runtime**
-  - only allocate heap memory when needed
-  - remove unused file func.go
-  - use package reflectlite
-* **transform**
-  - cherry-pick from #4774
-
-
-0.36.0
----
-* **general**
-  - add initial Go 1.24 support
-  - add support for LLVM 19
-  - update license for 2025
-  - make small corrections for README regarding wasm
-  - use GOOS and GOARCH for building wasm simulated boards
-  - only infer target for wasm when GOOS and GOARCH are set correctly, not just based on file extension
-  - add test-corpus-wasip2
-  - use older image for cross-compiling builds
-  - update Linux builds to run on ubuntu-latest since 20.04 is being retired
-  - ensure build output directory is created
-  - add NoSandbox flag to chrome headless that is run during WASM tests, since this is now required for Ubuntu 23+ and we are using Ubuntu 24+ when running Github Actions
-  - update wasmtime used for CI to 29.0.1 to fix issue with install during CI tests
-  - update to use `Get-CimInstance` as `wmic` is being deprecated on WIndows
-  - remove unnecessary executable permissions
-  - `goenv`: update to new v0.36.0 development version
-* **compiler**
-  - `builder`: fix parsing of external ld.lld error messages
-  - `cgo`: mangle identifier names
-  - `interp`: correctly mark functions as modifying memory
-  - add buildmode=wasi-legacy to support existing base of users who expected the older behavior for wasi modules to not return an exit code as if they were reactors
-* **standard library**
-  - `crypto/tls`: add Dialer.DialContext() to fix websocket client
-  - `crypto/tls`: add VersionTLS constants and VersionName(version uint16) method that turns it into a string, copied from big go
-  - `internal/syscall/unix`: use our own version of this package
-  - `machine`: replace hard-coded cpu frequencies on rp2xxx
-  - `machine`: bump rp2350 CPUFrequency to 150 MHz
-  - `machine`: compute rp2 clock dividers from crystal and target frequency
-  - `machine`: remove bytes package dependency in flash code
-  - `machine/usb/descriptor`: avoid bytes package
-  - `net`: update to latest submodule with httptest subpackage and ResolveIPAddress implementation
-  - `os`: add File.Chdir support
-  - `os`: implement stub Chdir for non-OS systems
-  - `os/file`: add file.Chmod
-  - `reflect`: implement Value.Equal
-  - `runtime`: add FIPS helper functions
-  - `runtime`: manually initialize xorshift state
-  - `sync`: move Mutex to internal/task
-  - `syscall`: add wasip1 RandomGet
-  - `testing`: add Chdir
-  - `wasip2`: add stubs to get internal/syscall/unix to work
-* **fixes**
-  - correctly handle calls for GetRNG() when being made from nrf devices with SoftDevice enabled
-  - fix stm32f103 ADC
-  - `wasm`: correctly handle id lookup for finalizeRef call
-  - `wasm`: avoid total failure on wasm finalizer call
-  - `wasm`: convert offset as signed int into unsigned int in syscall/js.stringVal in wasm_exec.js
-* **targets**
-  - rp2350: add pll generalized solution; fix ADC handles; pwm period fix
-  - rp2350: extending support to include the rp2350b
-  - rp2350: cleanup: unexport internal USB and clock package variable, consts and types
-  - nrf: make ADC resolution changeable
-  - turn on GC for TKey1 device, since it does in fact work
-  - match Pico2 stack size to Pico
-* **boards**
-  - add support for Pimoroni Pico Plus2
-  - add target for pico2-w board
-  - add comboat_fw tag for elecrow W5 boards with Combo-AT Wifi firmware
-  - add support for Elecrow Pico rp2350 W5 boards
-  - add support for Elecrow Pico rp2040 W5 boards
-  - add support for NRF51 HW-651
-  - add support for esp32c3-supermini
-  - add support for waveshare-rp2040-tiny
-* **examples**
-  - add naive debouncing for pininterrupt example
-
-
 0.35.0
 ---
 * **general**

Dockerfile

@@ -1,8 +1,8 @@
 # tinygo-llvm stage obtains the llvm source for TinyGo
-FROM golang:1.27 AS tinygo-llvm
+FROM golang:1.23 AS tinygo-llvm
 
 RUN apt-get update && \
-    apt-get install -y apt-utils make cmake clang-17 ninja-build && \
+    apt-get install -y apt-utils make cmake clang-15 ninja-build && \
     rm -rf \
         /var/lib/apt/lists/* \
         /var/log/* \
@@ -10,7 +10,6 @@ RUN apt-get update && \
         /tmp/*
 
 COPY ./GNUmakefile /tinygo/GNUmakefile
-COPY ./make /tinygo/make
 
 RUN cd /tinygo/ && \
     make llvm-source
@@ -34,7 +33,7 @@ RUN cd /tinygo/ && \
 
 # tinygo-compiler copies the compiler build over to a base Go container (without
 # all the build tools etc).
-FROM golang:1.27 AS tinygo-compiler
+FROM golang:1.23 AS tinygo-compiler
 
 # Copy tinygo build.
 COPY --from=tinygo-compiler-build /tinygo/build/release/tinygo /tinygo

LICENSE

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

README.md

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

builder/ar.go

@@ -3,7 +3,6 @@ package builder
 import (
 	"bytes"
 	"debug/elf"
-	"debug/macho"
 	"debug/pe"
 	"encoding/binary"
 	"errors"
@@ -63,20 +62,6 @@ func makeArchive(arfile *os.File, objs []string) error {
 					fileIndex int
 				}{symbol.Name, i})
 			}
-		} else if dbg, err := macho.NewFile(objfile); err == nil {
-			for _, symbol := range dbg.Symtab.Syms {
-				// See mach-o/nlist.h
-				if symbol.Type&0x0e != 0xe { // (symbol.Type & N_TYPE) != N_SECT
-					continue // undefined symbol
-				}
-				if symbol.Type&0x01 == 0 { // (symbol.Type & N_EXT) == 0
-					continue // internal symbol (static, etc)
-				}
-				symbolTable = append(symbolTable, struct {
-					name      string
-					fileIndex int
-				}{symbol.Name, i})
-			}
 		} else if dbg, err := pe.NewFile(objfile); err == nil {
 			for _, symbol := range dbg.Symbols {
 				if symbol.StorageClass != 2 {

builder/bdwgc.go

@@ -1,91 +0,0 @@
-package builder
-
-// The well-known conservative Boehm-Demers-Weiser GC.
-// This file provides a way to compile this GC for use with TinyGo.
-
-import (
-	"path/filepath"
-	"strings"
-
-	"github.com/tinygo-org/tinygo/goenv"
-)
-
-var BoehmGC = Library{
-	name: "bdwgc",
-	cflags: func(target, headerPath string) []string {
-		libdir := filepath.Join(goenv.Get("TINYGOROOT"), "lib/bdwgc")
-		flags := []string{
-			// use a modern environment
-			"-DUSE_MMAP",              // mmap is available
-			"-DUSE_MUNMAP",            // return memory to the OS using munmap
-			"-DGC_BUILTIN_ATOMIC",     // use compiler intrinsics for atomic operations
-			"-DNO_EXECUTE_PERMISSION", // don't make the heap executable
-
-			// specific flags for TinyGo
-			"-DALL_INTERIOR_POINTERS",  // scan interior pointers (needed for Go)
-			"-DIGNORE_DYNAMIC_LOADING", // we don't support dynamic loading at the moment
-			"-DNO_GETCONTEXT",          // musl doesn't support getcontext()
-			"-DGC_DISABLE_INCREMENTAL", // don't mess with SIGSEGV and such
-
-			// Use a minimal environment.
-			"-DNO_MSGBOX_ON_ERROR", // don't call MessageBoxA on Windows
-			"-DDONT_USE_ATEXIT",
-			"-DNO_GETENV",          // smaller binary, more predictable configuration
-			"-DNO_CLOCK",           // don't use system clock
-			"-DNO_DEBUGGING",       // reduce code size
-			"-DGC_NO_FINALIZATION", // finalization is not used at the moment
-
-			// Special flag to work around the lack of __data_start in ld.lld.
-			// TODO: try to fix this in LLVM/lld directly so we don't have to
-			// work around it anymore.
-			"-DGC_DONT_REGISTER_MAIN_STATIC_DATA",
-
-			// Do not scan the stack. We have our own mechanism to do this.
-			"-DSTACK_NOT_SCANNED",
-			"-DNO_PROC_STAT",  // we scan the stack manually (don't read /proc/self/stat on Linux)
-			"-DSTACKBOTTOM=0", // dummy value, we scan the stack manually
-
-			// Assertions can be enabled while debugging GC issues.
-			//"-DGC_ASSERTIONS",
-
-			// We use our own way of dealing with threads (that is a bit hacky).
-			// See src/runtime/gc_boehm.go.
-			//"-DGC_THREADS",
-			//"-DTHREAD_LOCAL_ALLOC",
-
-			"-I" + libdir + "/include",
-		}
-		return flags
-	},
-	needsLibc: true,
-	sourceDir: func() string {
-		return filepath.Join(goenv.Get("TINYGOROOT"), "lib/bdwgc")
-	},
-	librarySources: func(target string, _ bool) ([]string, error) {
-		sources := []string{
-			"allchblk.c",
-			"alloc.c",
-			"blacklst.c",
-			"dbg_mlc.c",
-			"dyn_load.c",
-			"headers.c",
-			"mach_dep.c",
-			"malloc.c",
-			"mark.c",
-			"mark_rts.c",
-			"misc.c",
-			"new_hblk.c",
-			"os_dep.c",
-			"reclaim.c",
-		}
-		if strings.Split(target, "-")[2] == "windows" {
-			// Due to how the linker on Windows works (that doesn't allow
-			// undefined functions), we need to include these extra files.
-			sources = append(sources,
-				"mallocx.c",
-				"ptr_chck.c",
-			)
-		}
-		return sources, nil
-	},
-}

builder/build.go

@@ -14,17 +14,15 @@ import (
 	"fmt"
 	"go/types"
 	"hash/crc32"
-	"maps"
+	"io/fs"
 	"math/bits"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"runtime"
-	"slices"
 	"sort"
 	"strconv"
 	"strings"
-	"sync"
 
 	"github.com/gofrs/flock"
 	"github.com/tinygo-org/tinygo/compileopts"
@@ -139,7 +137,9 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 		if _, ok := globalValues[pkgPath]; !ok {
 			globalValues[pkgPath] = map[string]string{}
 		}
-		maps.Copy(globalValues[pkgPath], vals)
+		for k, v := range vals {
+			globalValues[pkgPath][k] = v
+		}
 	}
 
 	// Check for a libc dependency.
@@ -149,17 +149,16 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 	var libcDependencies []*compileJob
 	switch config.Target.Libc {
 	case "darwin-libSystem":
-		libcJob := makeDarwinLibSystemJob(config, tmpdir)
-		libcDependencies = append(libcDependencies, libcJob)
+		job := makeDarwinLibSystemJob(config, tmpdir)
+		libcDependencies = append(libcDependencies, job)
 	case "musl":
-		var unlock func()
-		libcJob, unlock, err := libMusl.load(config, tmpdir)
+		job, unlock, err := libMusl.load(config, tmpdir)
 		if err != nil {
 			return BuildResult{}, err
 		}
 		defer unlock()
-		libcDependencies = append(libcDependencies, dummyCompileJob(filepath.Join(filepath.Dir(libcJob.result), "crt1.o")))
-		libcDependencies = append(libcDependencies, libcJob)
+		libcDependencies = append(libcDependencies, dummyCompileJob(filepath.Join(filepath.Dir(job.result), "crt1.o")))
+		libcDependencies = append(libcDependencies, job)
 	case "picolibc":
 		libcJob, unlock, err := libPicolibc.load(config, tmpdir)
 		if err != nil {
@@ -168,12 +167,11 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 		defer unlock()
 		libcDependencies = append(libcDependencies, libcJob)
 	case "wasi-libc":
-		libcJob, unlock, err := libWasiLibc.load(config, tmpdir)
-		if err != nil {
-			return BuildResult{}, err
+		path := filepath.Join(root, "lib/wasi-libc/sysroot/lib/wasm32-wasi/libc.a")
+		if _, err := os.Stat(path); errors.Is(err, fs.ErrNotExist) {
+			return BuildResult{}, errors.New("could not find wasi-libc, perhaps you need to run `make wasi-libc`?")
 		}
-		defer unlock()
-		libcDependencies = append(libcDependencies, libcJob)
+		libcDependencies = append(libcDependencies, dummyCompileJob(path))
 	case "wasmbuiltins":
 		libcJob, unlock, err := libWasmBuiltins.load(config, tmpdir)
 		if err != nil {
@@ -182,12 +180,12 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 		defer unlock()
 		libcDependencies = append(libcDependencies, libcJob)
 	case "mingw-w64":
-		libcJob, unlock, err := libMinGW.load(config, tmpdir)
+		job, unlock, err := libMinGW.load(config, tmpdir)
 		if err != nil {
 			return BuildResult{}, err
 		}
 		defer unlock()
-		libcDependencies = append(libcDependencies, libcJob)
+		libcDependencies = append(libcDependencies, job)
 		libcDependencies = append(libcDependencies, makeMinGWExtraLibs(tmpdir, config.GOARCH())...)
 	case "":
 		// no library specified, so nothing to do
@@ -215,7 +213,6 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 		MaxStackAlloc:      config.MaxStackAlloc(),
 		NeedsStackObjects:  config.NeedsStackObjects(),
 		Debug:              !config.Options.SkipDWARF, // emit DWARF except when -internal-nodwarf is passed
-		Nobounds:           config.Options.Nobounds,
 		PanicStrategy:      config.PanicStrategy(),
 	}
 
@@ -255,22 +252,9 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 		result.PackagePathMap[pkg.OriginalDir()] = pkg.Pkg.Path()
 	}
 
-	// Strip default initializers for -X globals from the type info before
-	// building SSA. This prevents go/ssa from emitting init stores for them,
-	// so that makeGlobalsModule can supply the correct values at final link
-	// time without any runtime init overwriting them. The -X values themselves
-	// are kept out of the per-package build cache; only the variable names
-	// appear in the cache key.
-	for _, pkg := range lprogram.Sorted() {
-		for name := range globalValues[pkg.Pkg.Path()] {
-			pkg.StripVarInitializer(name)
-		}
-	}
-
 	// Create the *ssa.Program. This does not yet build the entire SSA of the
 	// program so it's pretty fast and doesn't need to be parallelized.
 	program := lprogram.LoadSSA()
-	buildProgram := sync.OnceFunc(program.Build)
 
 	// Add jobs to compile each package.
 	// Packages that have a cache hit will not be compiled again.
@@ -279,6 +263,7 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 
 	var embedFileObjects []*compileJob
 	for _, pkg := range lprogram.Sorted() {
+		pkg := pkg // necessary to avoid a race condition
 
 		var undefinedGlobals []string
 		for name := range globalValues[pkg.Pkg.Path()] {
@@ -294,13 +279,9 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 				allFiles[file.Name] = append(allFiles[file.Name], file)
 			}
 		}
-		// Sort embedded files by name to maintain output determinism.
-		embedNames := make([]string, 0, len(allFiles))
-		for _, files := range allFiles {
-			embedNames = append(embedNames, files[0].Name)
-		}
-		slices.Sort(embedNames)
-		for _, name := range embedNames {
+		for name, files := range allFiles {
+			name := name
+			files := files
 			job := &compileJob{
 				description: "make object file for " + name,
 				run: func(job *compileJob) error {
@@ -315,7 +296,7 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 					sum := sha256.Sum256(data)
 					hexSum := hex.EncodeToString(sum[:16])
 
-					for _, file := range allFiles[name] {
+					for _, file := range files {
 						file.Size = uint64(len(data))
 						file.Hash = hexSum
 						if file.NeedsData {
@@ -400,13 +381,8 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 					return nil
 				}
 
-				// SSA package builds may run concurrently, but the resulting
-				// functions cannot be inspected until all builds have finished:
-				// generic instances and wrappers can be shared across packages.
-				// Build the whole program once before compiling any package.
-				buildProgram()
-
-				// Compile AST to IR.
+				// Compile AST to IR. The compiler.CompilePackage function will
+				// build the SSA as needed.
 				mod, errs := compiler.CompilePackage(pkg.ImportPath, pkg, program.Package(pkg.Pkg), machine, compilerConfig, config.DumpSSA())
 				defer mod.Context().Dispose()
 				defer mod.Dispose()
@@ -473,15 +449,8 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 					if global.IsNil() {
 						return errors.New("global not found: " + globalName)
 					}
-					globalType := global.GlobalValueType()
-					if globalType.TypeKind() != llvm.StructTypeKind || globalType.StructName() != "runtime._string" {
-						// Verify this is indeed a string. This is needed so
-						// that makeGlobalsModule can just create the right
-						// globals of string type without checking.
-						return fmt.Errorf("%s: not a string", globalName)
-					}
 					name := global.Name()
-					newGlobal := llvm.AddGlobal(mod, globalType, name+".tmp")
+					newGlobal := llvm.AddGlobal(mod, global.GlobalValueType(), name+".tmp")
 					global.ReplaceAllUsesWith(newGlobal)
 					global.EraseFromParentAsGlobal()
 					newGlobal.SetName(name)
@@ -494,7 +463,7 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 				if pkgInit.IsNil() {
 					panic("init not found for " + pkg.Pkg.Path())
 				}
-				err := interp.RunFunc(pkgInit, config.Options.InterpTimeout, config.Options.InterpMaxLoopIterations, config.DumpSSA())
+				err := interp.RunFunc(pkgInit, config.Options.InterpTimeout, config.DumpSSA())
 				if err != nil {
 					return err
 				}
@@ -563,38 +532,12 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 				if err != nil {
 					return fmt.Errorf("failed to load bitcode file: %w", err)
 				}
-				// Resolve duplicate function definitions before linking.
-				// This can happen when a newer Go version adds a function
-				// body in a standard library package that was previously
-				// just a declaration provided by //go:linkname from the
-				// runtime. In that case, keep the existing (runtime)
-				// definition by weakening the new one's linkage so the
-				// LLVM linker discards it in favor of the existing one.
-				for fn := pkgMod.FirstFunction(); !fn.IsNil(); fn = llvm.NextFunction(fn) {
-					if fn.IsDeclaration() {
-						continue
-					}
-					existing := mod.NamedFunction(fn.Name())
-					if existing.IsNil() || existing.IsDeclaration() {
-						continue
-					}
-					fn.SetLinkage(llvm.LinkOnceODRLinkage)
-				}
 				err = llvm.LinkModules(mod, pkgMod)
 				if err != nil {
 					return fmt.Errorf("failed to link module: %w", err)
 				}
 			}
 
-			// Insert values from -ldflags="-X ..." into the IR.
-			// This is a separate module, so that the "runtime._string" type
-			// doesn't need to match precisely. LLVM tends to rename that type
-			// sometimes, leading to errors. But linking in a separate module
-			// works fine. See:
-			// https://github.com/tinygo-org/tinygo/issues/4810
-			globalsMod := makeGlobalsModule(ctx, globalValues, machine)
-			llvm.LinkModules(mod, globalsMod)
-
 			// Create runtime.initAll function that calls the runtime
 			// initializer of each package.
 			llvmInitFn := mod.NamedFunction("runtime.initAll")
@@ -647,7 +590,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, globalValues)
 			if err != nil {
 				return err
 			}
@@ -750,16 +693,6 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 		linkerDependencies = append(linkerDependencies, job)
 	}
 
-	// The Boehm collector is stored in a separate C library.
-	if config.GC() == "boehm" {
-		job, unlock, err := BoehmGC.load(config, tmpdir)
-		if err != nil {
-			return BuildResult{}, err
-		}
-		defer unlock()
-		linkerDependencies = append(linkerDependencies, job)
-	}
-
 	// Add jobs to compile extra files. These files are in C or assembly and
 	// contain things like the interrupt vector table and low level operations
 	// such as stack switching.
@@ -780,6 +713,7 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 	// TODO: do this as part of building the package to be able to link the
 	// bitcode files together.
 	for _, pkg := range lprogram.Sorted() {
+		pkg := pkg
 		for _, filename := range pkg.CFiles {
 			abspath := filepath.Join(pkg.OriginalDir(), filename)
 			job := &compileJob{
@@ -846,25 +780,22 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 			}
 			ldflags = append(ldflags, "-mllvm", "-mcpu="+config.CPU())
 			ldflags = append(ldflags, "-mllvm", "-mattr="+config.Features()) // needed for MIPS softfloat
-			switch config.LinkerFlavor() {
-			case "coff":
-				// Options for driving ld.lld in PE/COFF mode.
+			if config.GOOS() == "windows" {
+				// Options for the MinGW wrapper for the lld COFF linker.
 				ldflags = append(ldflags,
 					"-Xlink=/opt:lldlto="+strconv.Itoa(speedLevel),
 					"--thinlto-cache-dir="+filepath.Join(cacheDir, "thinlto"))
-			case "darwin":
+			} else if config.GOOS() == "darwin" {
 				// Options for the ld64-compatible lld linker.
 				ldflags = append(ldflags,
 					"--lto-O"+strconv.Itoa(speedLevel),
 					"-cache_path_lto", filepath.Join(cacheDir, "thinlto"))
-			case "gnu":
+			} else {
 				// Options for the ELF linker.
 				ldflags = append(ldflags,
 					"--lto-O"+strconv.Itoa(speedLevel),
 					"--thinlto-cache-dir="+filepath.Join(cacheDir, "thinlto"),
 				)
-			default:
-				return fmt.Errorf("unknown linker flavor: %s", config.LinkerFlavor())
 			}
 			if config.CodeModel() != "default" {
 				ldflags = append(ldflags,
@@ -921,7 +852,7 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 			}
 
 			// Run wasm-opt for wasm binaries
-			if arch, _, _ := strings.Cut(config.Triple(), "-"); arch == "wasm32" {
+			if arch := strings.Split(config.Triple(), "-")[0]; arch == "wasm32" {
 				optLevel, _, _ := config.OptLevel()
 				opt := "-" + optLevel
 
@@ -1083,11 +1014,11 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 		if err != nil {
 			return result, err
 		}
-	case "esp32", "esp32-img", "esp32c3", "esp32s3", "esp32c6", "esp8266":
+	case "esp32", "esp32-img", "esp32c3", "esp8266":
 		// Special format for the ESP family of chips (parsed by the ROM
 		// bootloader).
 		result.Binary = filepath.Join(tmpdir, "main"+outext)
-		err := makeESPFirmwareImage(result.Executable, result.Binary, outputBinaryFormat)
+		err := makeESPFirmareImage(result.Executable, result.Binary, outputBinaryFormat)
 		if err != nil {
 			return result, err
 		}
@@ -1214,8 +1145,8 @@ func createEmbedObjectFile(data, hexSum, sourceFile, sourceDir, tmpdir string, c
 // optimizeProgram runs a series of optimizations and transformations that are
 // needed to convert a program to its final form. Some transformations are not
 // optional and must be run as the compiler expects them to run.
-func optimizeProgram(mod llvm.Module, config *compileopts.Config) error {
-	err := interp.Run(mod, config.Options.InterpTimeout, config.Options.InterpMaxLoopIterations, config.DumpSSA())
+func optimizeProgram(mod llvm.Module, config *compileopts.Config, globalValues map[string]map[string]string) error {
+	err := interp.Run(mod, config.Options.InterpTimeout, config.DumpSSA())
 	if err != nil {
 		return err
 	}
@@ -1232,6 +1163,12 @@ func optimizeProgram(mod llvm.Module, config *compileopts.Config) error {
 		}
 	}
 
+	// Insert values from -ldflags="-X ..." into the IR.
+	err = setGlobalValues(mod, globalValues)
+	if err != nil {
+		return err
+	}
+
 	// Run most of the whole-program optimizations (including the whole
 	// O0/O1/O2/Os/Oz optimization pipeline).
 	errs := transform.Optimize(mod, config)
@@ -1245,19 +1182,10 @@ func optimizeProgram(mod llvm.Module, config *compileopts.Config) error {
 	return nil
 }
 
-func makeGlobalsModule(ctx llvm.Context, globals map[string]map[string]string, machine llvm.TargetMachine) llvm.Module {
-	mod := ctx.NewModule("cmdline-globals")
-	targetData := machine.CreateTargetData()
-	defer targetData.Dispose()
-	mod.SetDataLayout(targetData.String())
-
-	stringType := ctx.StructCreateNamed("runtime._string")
-	uintptrType := ctx.IntType(targetData.PointerSize() * 8)
-	stringType.StructSetBody([]llvm.Type{
-		llvm.PointerType(ctx.Int8Type(), 0),
-		uintptrType,
-	}, false)
-
+// setGlobalValues sets the global values from the -ldflags="-X ..." compiler
+// option in the given module. An error may be returned if the global is not of
+// the expected type.
+func setGlobalValues(mod llvm.Module, globals map[string]map[string]string) error {
 	var pkgPaths []string
 	for pkgPath := range globals {
 		pkgPaths = append(pkgPaths, pkgPath)
@@ -1273,6 +1201,24 @@ func makeGlobalsModule(ctx llvm.Context, globals map[string]map[string]string, m
 		for _, name := range names {
 			value := pkg[name]
 			globalName := pkgPath + "." + name
+			global := mod.NamedGlobal(globalName)
+			if global.IsNil() || !global.Initializer().IsNil() {
+				// The global either does not exist (optimized away?) or has
+				// some value, in which case it has already been initialized at
+				// package init time.
+				continue
+			}
+
+			// A strin is a {ptr, len} pair. We need these types to build the
+			// initializer.
+			initializerType := global.GlobalValueType()
+			if initializerType.TypeKind() != llvm.StructTypeKind || initializerType.StructName() == "" {
+				return fmt.Errorf("%s: not a string", globalName)
+			}
+			elementTypes := initializerType.StructElementTypes()
+			if len(elementTypes) != 2 {
+				return fmt.Errorf("%s: not a string", globalName)
+			}
 
 			// Create a buffer for the string contents.
 			bufInitializer := mod.Context().ConstString(value, false)
@@ -1283,20 +1229,22 @@ func makeGlobalsModule(ctx llvm.Context, globals map[string]map[string]string, m
 			buf.SetLinkage(llvm.PrivateLinkage)
 
 			// Create the string value, which is a {ptr, len} pair.
-			length := llvm.ConstInt(uintptrType, uint64(len(value)), false)
-			initializer := llvm.ConstNamedStruct(stringType, []llvm.Value{
-				buf,
+			zero := llvm.ConstInt(mod.Context().Int32Type(), 0, false)
+			ptr := llvm.ConstGEP(bufInitializer.Type(), buf, []llvm.Value{zero, zero})
+			if ptr.Type() != elementTypes[0] {
+				return fmt.Errorf("%s: not a string", globalName)
+			}
+			length := llvm.ConstInt(elementTypes[1], uint64(len(value)), false)
+			initializer := llvm.ConstNamedStruct(initializerType, []llvm.Value{
+				ptr,
 				length,
 			})
 
-			// Create the string global.
-			global := llvm.AddGlobal(mod, stringType, globalName)
+			// Set the initializer. No initializer should be set at this point.
 			global.SetInitializer(initializer)
-			global.SetAlignment(targetData.PrefTypeAlignment(stringType))
 		}
 	}
-
-	return mod
+	return nil
 }
 
 // functionStackSizes keeps stack size information about a single function
@@ -1359,14 +1307,6 @@ func determineStackSizes(mod llvm.Module, executable string) ([]string, map[stri
 	}
 	baseStackSize, baseStackSizeType, baseStackSizeFailedAt := functions["tinygo_startTask"][0].StackSize()
 
-	// Account for the bytes that tinygo_swapTask pushes onto the goroutine stack
-	// on every context switch. The static analysis correctly traces Go calls,
-	// but it cannot see into the assembly-level register push.
-	var contextSwitchOverhead uint64
-	if swapFuncs, ok := functions["tinygo_swapTask"]; ok && len(swapFuncs) == 1 {
-		contextSwitchOverhead = swapFuncs[0].FrameSize
-	}
-
 	sizes := make(map[string]functionStackSize)
 
 	// Add the reset handler function, for convenience. The reset handler runs
@@ -1415,12 +1355,6 @@ func determineStackSizes(mod llvm.Module, executable string) ([]string, map[stri
 			// overflow will occur even before the goroutine is started.
 			stackSize = baseStackSize
 		}
-		if stackSizeType == stacksize.Bounded {
-			// Add the overhead of context switching. This is needed because the
-			// context switch (tinygo_swapTask) pushes callee-saved registers
-			// onto the current stack, which is not seen by the static analysis.
-			stackSize += contextSwitchOverhead
-		}
 		sizes[name] = functionStackSize{
 			stackSize:        stackSize,
 			stackSizeType:    stackSizeType,

builder/builder_test.go

@@ -5,7 +5,6 @@ import (
 	"os"
 	"path/filepath"
 	"runtime"
-	"strings"
 	"testing"
 
 	"github.com/tinygo-org/tinygo/compileopts"
@@ -29,15 +28,12 @@ func TestClangAttributes(t *testing.T) {
 		"cortex-m4",
 		"cortex-m7",
 		"esp32c3",
-		"esp32c6",
-		"esp32s3",
 		"fe310",
 		"gameboy-advance",
 		"k210",
 		"nintendoswitch",
 		"riscv-qemu",
 		"tkey",
-		"uefi-amd64",
 		"wasip1",
 		"wasip2",
 		"wasm",
@@ -49,6 +45,7 @@ func TestClangAttributes(t *testing.T) {
 		targetNames = append(targetNames, "esp32", "esp8266")
 	}
 	for _, targetName := range targetNames {
+		targetName := targetName
 		t.Run(targetName, func(t *testing.T) {
 			testClangAttributes(t, &compileopts.Options{Target: targetName})
 		})
@@ -70,9 +67,9 @@ func TestClangAttributes(t *testing.T) {
 		{GOOS: "linux", GOARCH: "mipsle", GOMIPS: "softfloat"},
 		{GOOS: "darwin", GOARCH: "amd64"},
 		{GOOS: "darwin", GOARCH: "arm64"},
-		{GOOS: "windows", GOARCH: "386"},
 		{GOOS: "windows", GOARCH: "amd64"},
 		{GOOS: "windows", GOARCH: "arm64"},
+		{GOOS: "wasip1", GOARCH: "wasm"},
 	} {
 		name := "GOOS=" + options.GOOS + ",GOARCH=" + options.GOARCH
 		if options.GOARCH == "arm" {
@@ -130,10 +127,8 @@ func testClangAttributes(t *testing.T, options *compileopts.Options) {
 	defer mod.Dispose()
 
 	// Check whether the LLVM target matches.
-	// Use ClangTriple since LLVM 22 normalizes wasm32-unknown-wasi to wasip1.
-	expectedTriple := compileopts.ClangTriple(config.Triple())
-	if mod.Target() != expectedTriple {
-		t.Errorf("target has LLVM triple %#v but Clang makes it LLVM triple %#v", expectedTriple, mod.Target())
+	if mod.Target() != config.Triple() {
+		t.Errorf("target has LLVM triple %#v but Clang makes it LLVM triple %#v", config.Triple(), mod.Target())
 	}
 
 	// Check the "target-cpu" and "target-features" string attribute of the add
@@ -157,65 +152,11 @@ func testClangAttributes(t *testing.T, options *compileopts.Options) {
 			// The reason is that Debian has patched Clang in a way that
 			// modifies the LLVM features string, changing lots of FPU/float
 			// related flags. We want to test vanilla Clang, not Debian Clang.
-			//
-			// Rather than requiring an exact match (which breaks across LLVM
-			// versions as new features are added), check that every feature
-			// TinyGo specifies is consistent with what Clang produces:
-			//  - A "+feature" in TinyGo must appear in Clang's output.
-			//  - A "-feature" in TinyGo must not be "+feature" in Clang's output.
-			checkFeatureFlags(t, config.Features(), features)
+			t.Errorf("target has LLVM features\n\t%#v\nbut Clang makes it\n\t%#v", config.Features(), features)
 		}
 	}
 }
 
-// checkFeatureFlags verifies that all features specified by TinyGo's target
-// configuration are consistent with Clang's output. This allows Clang to add
-// new features across LLVM versions without breaking the test.
-func checkFeatureFlags(t *testing.T, targetFeatures, clangFeatures string) {
-	t.Helper()
-
-	// Build a set of Clang's features for fast lookup.
-	clangSet := make(map[string]bool) // feature name -> enabled
-	for _, f := range strings.Split(clangFeatures, ",") {
-		f = strings.TrimSpace(f)
-		if len(f) < 2 {
-			continue
-		}
-		enabled := f[0] == '+'
-		name := f[1:]
-		clangSet[name] = enabled
-	}
-
-	// Check each feature that TinyGo specifies.
-	var missing, conflicts []string
-	for _, f := range strings.Split(targetFeatures, ",") {
-		f = strings.TrimSpace(f)
-		if len(f) < 2 {
-			continue
-		}
-		wantEnabled := f[0] == '+'
-		name := f[1:]
-
-		clangEnabled, inClang := clangSet[name]
-		if wantEnabled && (!inClang || !clangEnabled) {
-			// TinyGo requires +feature but Clang doesn't enable it.
-			missing = append(missing, f)
-		} else if !wantEnabled && inClang && clangEnabled {
-			// TinyGo requires -feature but Clang enables it.
-			conflicts = append(conflicts, fmt.Sprintf("target has %q but Clang has %q", f, "+"+name))
-		}
-	}
-
-	if len(missing) > 0 {
-		t.Errorf("target specifies features not present in Clang output: %s\n\ttarget features: %s\n\tclang features:  %s",
-			strings.Join(missing, ", "), targetFeatures, clangFeatures)
-	}
-	if len(conflicts) > 0 {
-		t.Errorf("target disables features that Clang enables: %s",
-			strings.Join(conflicts, "; "))
-	}
-}
-
 // This TestMain is necessary because TinyGo may also be invoked to run certain
 // LLVM tools in a separate process. Not capturing these invocations would lead
 // to recursive tests.

builder/builtins.go

@@ -3,7 +3,6 @@ package builder
 import (
 	"os"
 	"path/filepath"
-	"strings"
 
 	"github.com/tinygo-org/tinygo/compileopts"
 	"github.com/tinygo-org/tinygo/goenv"
@@ -202,22 +201,6 @@ var avrBuiltins = []string{
 	"avr/udivmodqi4.S",
 }
 
-// Builtins needed specifically for windows/386.
-var windowsI386Builtins = []string{
-	"i386/chkstk.S",  // __chkstk_ms
-	"i386/chkstk2.S", // _alloca (__alloca)
-}
-
-// Builtins needed specifically for windows/amd64.
-var windowsAMD64Builtins = []string{
-	"x86_64/chkstk.S",
-}
-
-// Builtins needed specifically for windows/arm64.
-var windowsARM64Builtins = []string{
-	"aarch64/chkstk.S",
-}
-
 // libCompilerRT is a library with symbols required by programs compiled with
 // LLVM. These symbols are for operations that cannot be emitted with a single
 // instruction or a short sequence of instructions for that target.
@@ -237,35 +220,16 @@ var libCompilerRT = Library{
 		// Development build.
 		return filepath.Join(goenv.Get("TINYGOROOT"), "lib/compiler-rt-builtins")
 	},
-	librarySources: func(target string, _ bool) ([]string, error) {
+	librarySources: func(target string) ([]string, error) {
 		builtins := append([]string{}, genericBuiltins...) // copy genericBuiltins
 		switch compileopts.CanonicalArchName(target) {
 		case "arm":
 			builtins = append(builtins, aeabiBuiltins...)
 		case "avr":
 			builtins = append(builtins, avrBuiltins...)
-		case "x86_64":
+		case "x86_64", "aarch64", "riscv64": // any 64-bit arch
 			builtins = append(builtins, genericBuiltins128...)
-			if isWindowsTriple(target) {
-				builtins = append(builtins, windowsAMD64Builtins...)
-			}
-		case "aarch64":
-			builtins = append(builtins, genericBuiltins128...)
-			if isWindowsTriple(target) {
-				builtins = append(builtins, windowsARM64Builtins...)
-			}
-		case "riscv64":
-			builtins = append(builtins, genericBuiltins128...)
-		case "i386":
-			if isWindowsTriple(target) {
-				builtins = append(builtins, windowsI386Builtins...)
-			}
 		}
 		return builtins, nil
 	},
 }
-
-func isWindowsTriple(target string) bool {
-	parts := strings.Split(target, "-")
-	return len(parts) > 2 && parts[2] == "windows"
-}

builder/cc.go

@@ -281,7 +281,7 @@ func parseDepFile(s string) ([]string, error) {
 	s = strings.ReplaceAll(s, "\\\n", " ")
 
 	// Only use the first line, which is expected to begin with "deps:".
-	line, _, _ := strings.Cut(s, "\n")
+	line := strings.SplitN(s, "\n", 2)[0]
 	if !strings.HasPrefix(line, "deps:") {
 		return nil, errors.New("readDepFile: expected 'deps:' prefix")
 	}

builder/cc1as.cpp

@@ -23,7 +23,7 @@
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Driver/DriverDiagnostic.h"
-#include "clang/Options/Options.h"
+#include "clang/Driver/Options.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
 #include "clang/Frontend/Utils.h"
@@ -35,7 +35,6 @@
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCContext.h"
-#include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCObjectWriter.h"
@@ -68,7 +67,8 @@
 #include <optional>
 #include <system_error>
 using namespace clang;
-using namespace clang::options;
+using namespace clang::driver;
+using namespace clang::driver::options;
 using namespace llvm;
 using namespace llvm::opt;
 
@@ -109,7 +109,7 @@ bool AssemblerInvocation::CreateFromArgs(AssemblerInvocation &Opts,
   // Construct the invocation.
 
   // Target Options
-  Opts.Triple = llvm::Triple(llvm::Triple::normalize(Args.getLastArgValue(OPT_triple)));
+  Opts.Triple = llvm::Triple::normalize(Args.getLastArgValue(OPT_triple));
   if (Arg *A = Args.getLastArg(options::OPT_darwin_target_variant_triple))
     Opts.DarwinTargetVariantTriple = llvm::Triple(A->getValue());
   if (Arg *A = Args.getLastArg(OPT_darwin_target_variant_sdk_version_EQ)) {
@@ -125,8 +125,8 @@ bool AssemblerInvocation::CreateFromArgs(AssemblerInvocation &Opts,
   Opts.Features = Args.getAllArgValues(OPT_target_feature);
 
   // Use the default target triple if unspecified.
-  if (Opts.Triple.getTriple().empty())
-    Opts.Triple = llvm::Triple(llvm::sys::getDefaultTargetTriple());
+  if (Opts.Triple.empty())
+    Opts.Triple = llvm::sys::getDefaultTargetTriple();
 
   // Language Options
   Opts.IncludePaths = Args.getAllArgValues(OPT_I);
@@ -144,6 +144,8 @@ bool AssemblerInvocation::CreateFromArgs(AssemblerInvocation &Opts,
             .Default(llvm::DebugCompressionType::None);
   }
 
+  Opts.RelaxELFRelocations = !Args.hasArg(OPT_mrelax_relocations_no);
+  Opts.SSE2AVX = Args.hasArg(OPT_msse2avx);
   if (auto *DwarfFormatArg = Args.getLastArg(OPT_gdwarf64, OPT_gdwarf32))
     Opts.Dwarf64 = DwarfFormatArg->getOption().matches(OPT_gdwarf64);
   Opts.DwarfVersion = getLastArgIntValue(Args, OPT_dwarf_version_EQ, 2, Diags);
@@ -234,9 +236,6 @@ bool AssemblerInvocation::CreateFromArgs(AssemblerInvocation &Opts,
   Opts.EmitCompactUnwindNonCanonical =
       Args.hasArg(OPT_femit_compact_unwind_non_canonical);
   Opts.Crel = Args.hasArg(OPT_crel);
-  Opts.ImplicitMapsyms = Args.hasArg(OPT_mmapsyms_implicit);
-  Opts.X86RelaxRelocations = !Args.hasArg(OPT_mrelax_relocations_no);
-  Opts.X86Sse2Avx = Args.hasArg(OPT_msse2avx);
 
   Opts.AsSecureLogFile = Args.getLastArgValue(OPT_as_secure_log_file);
 
@@ -267,7 +266,7 @@ static bool ExecuteAssemblerImpl(AssemblerInvocation &Opts,
   std::string Error;
   const Target *TheTarget = TargetRegistry::lookupTarget(Opts.Triple, Error);
   if (!TheTarget)
-    return Diags.Report(diag::err_target_unknown_triple) << Opts.Triple.str();
+    return Diags.Report(diag::err_target_unknown_triple) << Opts.Triple;
 
   ErrorOr<std::unique_ptr<MemoryBuffer>> Buffer =
       MemoryBuffer::getFileOrSTDIN(Opts.InputFile, /*IsText=*/true);
@@ -295,9 +294,8 @@ static bool ExecuteAssemblerImpl(AssemblerInvocation &Opts,
   MCOptions.EmitCompactUnwindNonCanonical = Opts.EmitCompactUnwindNonCanonical;
   MCOptions.MCSaveTempLabels = Opts.SaveTemporaryLabels;
   MCOptions.Crel = Opts.Crel;
-  MCOptions.ImplicitMapSyms = Opts.ImplicitMapsyms;
-  MCOptions.X86RelaxRelocations = Opts.X86RelaxRelocations;
-  MCOptions.X86Sse2Avx = Opts.X86Sse2Avx;
+  MCOptions.X86RelaxRelocations = Opts.RelaxELFRelocations;
+  MCOptions.X86Sse2Avx = Opts.SSE2AVX;
   MCOptions.CompressDebugSections = Opts.CompressDebugSections;
   MCOptions.AsSecureLogFile = Opts.AsSecureLogFile;
 
@@ -327,7 +325,7 @@ static bool ExecuteAssemblerImpl(AssemblerInvocation &Opts,
       TheTarget->createMCSubtargetInfo(Opts.Triple, Opts.CPU, FS));
   assert(STI && "Unable to create subtarget info!");
 
-  MCContext Ctx(Opts.Triple, MAI.get(), MRI.get(), STI.get(), &SrcMgr,
+  MCContext Ctx(Triple(Opts.Triple), MAI.get(), MRI.get(), STI.get(), &SrcMgr,
                 &MCOptions);
 
   bool PIC = false;
@@ -345,6 +343,10 @@ static bool ExecuteAssemblerImpl(AssemblerInvocation &Opts,
   // MCObjectFileInfo needs a MCContext reference in order to initialize itself.
   std::unique_ptr<MCObjectFileInfo> MOFI(
       TheTarget->createMCObjectFileInfo(Ctx, PIC));
+  if (Opts.DarwinTargetVariantTriple)
+    MOFI->setDarwinTargetVariantTriple(*Opts.DarwinTargetVariantTriple);
+  if (!Opts.DarwinTargetVariantSDKVersion.empty())
+    MOFI->setDarwinTargetVariantSDKVersion(Opts.DarwinTargetVariantSDKVersion);
   Ctx.setObjectFileInfo(MOFI.get());
 
   if (Opts.GenDwarfForAssembly)
@@ -390,8 +392,8 @@ static bool ExecuteAssemblerImpl(AssemblerInvocation &Opts,
 
   // FIXME: There is a bit of code duplication with addPassesToEmitFile.
   if (Opts.OutputType == AssemblerInvocation::FT_Asm) {
-    std::unique_ptr<MCInstPrinter> IP(TheTarget->createMCInstPrinter(
-        Opts.Triple, Opts.OutputAsmVariant, *MAI, *MCII, *MRI));
+    MCInstPrinter *IP = TheTarget->createMCInstPrinter(
+        llvm::Triple(Opts.Triple), Opts.OutputAsmVariant, *MAI, *MCII, *MRI);
 
     std::unique_ptr<MCCodeEmitter> CE;
     if (Opts.ShowEncoding)
@@ -400,7 +402,7 @@ static bool ExecuteAssemblerImpl(AssemblerInvocation &Opts,
         TheTarget->createMCAsmBackend(*STI, *MRI, MCOptions));
 
     auto FOut = std::make_unique<formatted_raw_ostream>(*Out);
-    Str.reset(TheTarget->createAsmStreamer(Ctx, std::move(FOut), std::move(IP),
+    Str.reset(TheTarget->createAsmStreamer(Ctx, std::move(FOut), IP,
                                            std::move(CE), std::move(MAB)));
   } else if (Opts.OutputType == AssemblerInvocation::FT_Null) {
     Str.reset(createNullStreamer(Ctx));
@@ -422,17 +424,10 @@ static bool ExecuteAssemblerImpl(AssemblerInvocation &Opts,
         DwoOS ? MAB->createDwoObjectWriter(*Out, *DwoOS)
               : MAB->createObjectWriter(*Out);
 
-    Triple T = Opts.Triple;
+    Triple T(Opts.Triple);
     Str.reset(TheTarget->createMCObjectStreamer(
         T, Ctx, std::move(MAB), std::move(OW), std::move(CE), *STI));
     Str.get()->initSections(Opts.NoExecStack, *STI);
-    if (T.isOSBinFormatMachO() && T.isOSDarwin()) {
-      Triple *TVT = Opts.DarwinTargetVariantTriple
-                        ? &*Opts.DarwinTargetVariantTriple
-                        : nullptr;
-      Str->emitVersionForTarget(T, VersionTuple(), TVT,
-                                Opts.DarwinTargetVariantSDKVersion);
-    }
   }
 
   // When -fembed-bitcode is passed to clang_as, a 1-byte marker
@@ -453,7 +448,7 @@ static bool ExecuteAssemblerImpl(AssemblerInvocation &Opts,
   std::unique_ptr<MCTargetAsmParser> TAP(
       TheTarget->createMCAsmParser(*STI, *Parser, *MCII, MCOptions));
   if (!TAP)
-    Failed = Diags.Report(diag::err_target_unknown_triple) << Opts.Triple.str();
+    Failed = Diags.Report(diag::err_target_unknown_triple) << Opts.Triple;
 
   // Set values for symbols, if any.
   for (auto &S : Opts.SymbolDefs) {
@@ -506,12 +501,12 @@ int cc1as_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
   InitializeAllAsmParsers();
 
   // Construct our diagnostic client.
-  DiagnosticOptions DiagOpts;
+  IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
   TextDiagnosticPrinter *DiagClient
-    = new TextDiagnosticPrinter(errs(), DiagOpts);
+    = new TextDiagnosticPrinter(errs(), &*DiagOpts);
   DiagClient->setPrefix("clang -cc1as");
   IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
-  DiagnosticsEngine Diags(DiagID, DiagOpts, DiagClient);
+  DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagClient);
 
   // Set an error handler, so that any LLVM backend diagnostics go through our
   // error handler.
@@ -528,7 +523,7 @@ int cc1as_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
         llvm::outs(), "clang -cc1as [options] file...",
         "Clang Integrated Assembler", /*ShowHidden=*/false,
         /*ShowAllAliases=*/false,
-        llvm::opt::Visibility(clang::options::CC1AsOption));
+        llvm::opt::Visibility(driver::options::CC1AsOption));
 
     return 0;
   }

builder/cc1as.h

@@ -20,7 +20,7 @@ struct AssemblerInvocation {
   /// @{
 
   /// The name of the target triple to assemble for.
-  llvm::Triple Triple;
+  std::string Triple;
 
   /// If given, the name of the target CPU to determine which instructions
   /// are legal.
@@ -45,6 +45,10 @@ struct AssemblerInvocation {
   LLVM_PREFERRED_TYPE(bool)
   unsigned GenDwarfForAssembly : 1;
   LLVM_PREFERRED_TYPE(bool)
+  unsigned RelaxELFRelocations : 1;
+  LLVM_PREFERRED_TYPE(bool)
+  unsigned SSE2AVX : 1;
+  LLVM_PREFERRED_TYPE(bool)
   unsigned Dwarf64 : 1;
   unsigned DwarfVersion;
   std::string DwarfDebugFlags;
@@ -107,19 +111,12 @@ struct AssemblerInvocation {
   EmitDwarfUnwindType EmitDwarfUnwind;
 
   // Whether to emit compact-unwind for non-canonical entries.
-  // Note: maybe overridden by other constraints.
+  // Note: maybe overriden by other constraints.
   LLVM_PREFERRED_TYPE(bool)
   unsigned EmitCompactUnwindNonCanonical : 1;
 
   LLVM_PREFERRED_TYPE(bool)
   unsigned Crel : 1;
-  LLVM_PREFERRED_TYPE(bool)
-  unsigned ImplicitMapsyms : 1;
-
-  LLVM_PREFERRED_TYPE(bool)
-  unsigned X86RelaxRelocations : 1;
-  LLVM_PREFERRED_TYPE(bool)
-  unsigned X86Sse2Avx : 1;
 
   /// The name of the relocation model to use.
   std::string RelocationModel;
@@ -142,7 +139,7 @@ struct AssemblerInvocation {
 
 public:
   AssemblerInvocation() {
-    Triple = llvm::Triple();
+    Triple = "";
     NoInitialTextSection = 0;
     InputFile = "-";
     OutputPath = "-";
@@ -151,6 +148,7 @@ public:
     ShowInst = 0;
     ShowEncoding = 0;
     RelaxAll = 0;
+    SSE2AVX = 0;
     NoExecStack = 0;
     FatalWarnings = 0;
     NoWarn = 0;
@@ -162,9 +160,6 @@ public:
     EmitDwarfUnwind = EmitDwarfUnwindType::Default;
     EmitCompactUnwindNonCanonical = false;
     Crel = false;
-    ImplicitMapsyms = 0;
-    X86RelaxRelocations = 0;
-    X86Sse2Avx = 0;
   }
 
   static bool CreateFromArgs(AssemblerInvocation &Res,

builder/clang.cpp

@@ -27,9 +27,9 @@ bool tinygo_clang_driver(int argc, char **argv) {
 	std::vector<const char*> args(argv, argv + argc);
 
 	// The compiler invocation needs a DiagnosticsEngine so it can report problems
-	clang::DiagnosticOptions DiagOpts;
-	clang::TextDiagnosticPrinter DiagnosticPrinter(llvm::errs(), DiagOpts);
-	clang::DiagnosticsEngine Diags(llvm::IntrusiveRefCntPtr<clang::DiagnosticIDs>(new clang::DiagnosticIDs()), DiagOpts, &DiagnosticPrinter, false);
+	llvm::IntrusiveRefCntPtr<clang::DiagnosticOptions> DiagOpts = new clang::DiagnosticOptions();
+	clang::TextDiagnosticPrinter DiagnosticPrinter(llvm::errs(), &*DiagOpts);
+	clang::DiagnosticsEngine Diags(llvm::IntrusiveRefCntPtr<clang::DiagnosticIDs>(new clang::DiagnosticIDs()), &*DiagOpts, &DiagnosticPrinter, false);
 
 	// Create the clang driver
 	clang::driver::Driver TheDriver(args[0], llvm::sys::getDefaultTargetTriple(), Diags);

builder/commands.go

@@ -17,7 +17,7 @@ import (
 var commands = map[string][]string{}
 
 func init() {
-	llvmMajor, _, _ := strings.Cut(llvm.Version, ".")
+	llvmMajor := strings.Split(llvm.Version, ".")[0]
 	commands["clang"] = []string{"clang-" + llvmMajor}
 	commands["ld.lld"] = []string{"ld.lld-" + llvmMajor, "ld.lld"}
 	commands["wasm-ld"] = []string{"wasm-ld-" + llvmMajor, "wasm-ld"}

builder/config.go

@@ -25,21 +25,18 @@ func NewConfig(options *compileopts.Options) (*compileopts.Config, error) {
 	}
 
 	// Version range supported by TinyGo.
-	const minorMin = 25 // when updating the min version, also update .github/workflows/compat.yml
-	const minorMax = 27
+	const minorMin = 19
+	const minorMax = 23
 
 	// Check that we support this Go toolchain version.
 	gorootMajor, gorootMinor, err := goenv.GetGorootVersion()
 	if err != nil {
 		return nil, err
 	}
-
-	if options.GoCompatibility {
-		if gorootMajor != 1 || gorootMinor < minorMin || gorootMinor > minorMax {
-			// Note: when this gets updated, also update the Go compatibility matrix:
-			// https://github.com/tinygo-org/tinygo-site/blob/dev/content/docs/reference/go-compat-matrix.md
-			return nil, fmt.Errorf("requires go version 1.%d through 1.%d, got go%d.%d", minorMin, minorMax, gorootMajor, gorootMinor)
-		}
+	if gorootMajor != 1 || gorootMinor < minorMin || gorootMinor > minorMax {
+		// Note: when this gets updated, also update the Go compatibility matrix:
+		// https://github.com/tinygo-org/tinygo-site/blob/dev/content/docs/reference/go-compat-matrix.md
+		return nil, fmt.Errorf("requires go version 1.19 through 1.23, got go%d.%d", gorootMajor, gorootMinor)
 	}
 
 	// Check that the Go toolchain version isn't too new, if we haven't been

builder/darwin-libsystem.go

@@ -15,7 +15,7 @@ func makeDarwinLibSystemJob(config *compileopts.Config, tmpdir string) *compileJ
 	return &compileJob{
 		description: "compile Darwin libSystem.dylib",
 		run: func(job *compileJob) (err error) {
-			arch, _, _ := strings.Cut(config.Triple(), "-")
+			arch := strings.Split(config.Triple(), "-")[0]
 			job.result = filepath.Join(tmpdir, "libSystem.dylib")
 			objpath := filepath.Join(tmpdir, "libSystem.o")
 			inpath := filepath.Join(goenv.Get("TINYGOROOT"), "lib/macos-minimal-sdk/src", arch, "libSystem.s")

builder/esp.go

@@ -23,7 +23,7 @@ type espImageSegment struct {
 	data []byte
 }
 
-// makeESPFirmwareImage converts an input ELF file to an image file for an ESP32 or
+// makeESPFirmareImage converts an input ELF file to an image file for an ESP32 or
 // ESP8266 chip. This is a special purpose image format just for the ESP chip
 // family, and is parsed by the on-chip mask ROM bootloader.
 //
@@ -31,7 +31,7 @@ type espImageSegment struct {
 // https://github.com/espressif/esptool/wiki/Firmware-Image-Format
 // https://github.com/espressif/esp-idf/blob/8fbb63c2a701c22ccf4ce249f43aded73e134a34/components/bootloader_support/include/esp_image_format.h#L58
 // https://github.com/espressif/esptool/blob/master/esptool.py
-func makeESPFirmwareImage(infile, outfile, format string) error {
+func makeESPFirmareImage(infile, outfile, format string) error {
 	inf, err := elf.Open(infile)
 	if err != nil {
 		return err
@@ -65,6 +65,15 @@ func makeESPFirmwareImage(infile, outfile, format string) error {
 	// Sort the segments by address. This is what esptool does too.
 	sort.SliceStable(segments, func(i, j int) bool { return segments[i].addr < segments[j].addr })
 
+	// Calculate checksum over the segment data. This is used in the image
+	// footer.
+	checksum := uint8(0xef)
+	for _, segment := range segments {
+		for _, b := range segment.data {
+			checksum ^= b
+		}
+	}
+
 	// Write first to an in-memory buffer, primarily so that we can easily
 	// calculate a hash over the entire image.
 	// An added benefit is that we don't need to check for errors all the time.
@@ -79,83 +88,6 @@ func makeESPFirmwareImage(infile, outfile, format string) error {
 		chip = format[:len(format)-len("-img")]
 	}
 
-	// For ESP32 (original): separate RAM segments (loadable by ROM bootloader)
-	// from flash-mapped segments (DROM/IROM, require MMU setup by startup code).
-	// The ROM bootloader on ESP32 does NOT handle flash-mapped segments —
-	// it tries to memcpy to the virtual address, which crashes.
-	var flashSegments []*espImageSegment
-	if chip == "esp32" {
-		var ramSegments []*espImageSegment
-		for _, seg := range segments {
-			if (seg.addr >= 0x3F400000 && seg.addr < 0x3F800000) || // DROM
-				(seg.addr >= 0x400D0000 && seg.addr < 0x40400000) { // IROM
-				flashSegments = append(flashSegments, seg)
-			} else {
-				ramSegments = append(ramSegments, seg)
-			}
-		}
-		segments = ramSegments
-	}
-
-	// ESP32 flash XIP: compute where the DROM segment will be placed in flash
-	// (page-aligned, right after the RAM segments) and patch the
-	// _drom_flash_addr variable so the startup code can program the cache MMU.
-	// This must happen before the checksum/hash are computed so the patched
-	// value is covered by both.
-	const esp32FlashBase = 0x1000 // esptool flashes the image at 0x1000
-	// The ESP32 flash cache MMU supports configurable page sizes down to 256 B. 64 KiB is the reset/default size.
-	// If the startup code ever changes the MMU page size, this constant must change too.
-	const esp32PageSize = 0x10000 // 64KB MMU pages
-	var esp32DromFlashAddr uint32
-	if chip == "esp32" && len(flashSegments) > 0 {
-		// Compute the size of the RAM portion of the image (everything the ROM
-		// bootloader loads, up to and including the appended SHA256 hash).
-		ramImageSize := 0
-		ramImageSize += 24 // image header (8) + trailer fields (16)
-		for _, seg := range segments {
-			ramImageSize += 8 + len(seg.data) // segment header + data (4-aligned)
-		}
-		ramImageSize += 16 - ramImageSize%16 // footer padding + checksum byte
-		ramImageSize += 32                   // appended SHA256 hash
-
-		// DROM flash address must be 64KB page-aligned.
-		esp32DromFlashAddr = uint32(esp32FlashBase+ramImageSize+esp32PageSize-1) &^ (esp32PageSize - 1)
-
-		// Patch _drom_flash_addr in whichever RAM segment contains it.
-		syms, _ := inf.Symbols()
-		var dromSymAddr uint64
-		for _, s := range syms {
-			if s.Name == "_drom_flash_addr" {
-				dromSymAddr = s.Value
-				break
-			}
-		}
-		if dromSymAddr == 0 {
-			return fmt.Errorf("ESP32: _drom_flash_addr symbol not found")
-		}
-		patched := false
-		for _, seg := range segments {
-			if dromSymAddr >= uint64(seg.addr) && dromSymAddr+4 <= uint64(seg.addr)+uint64(len(seg.data)) {
-				off := int(dromSymAddr - uint64(seg.addr))
-				binary.LittleEndian.PutUint32(seg.data[off:], esp32DromFlashAddr)
-				patched = true
-				break
-			}
-		}
-		if !patched {
-			return fmt.Errorf("ESP32: _drom_flash_addr (0x%x) not in any RAM segment", dromSymAddr)
-		}
-	}
-
-	// Calculate checksum over the segment data. This is used in the image
-	// footer.
-	checksum := uint8(0xef)
-	for _, segment := range segments {
-		for _, b := range segment.data {
-			checksum ^= b
-		}
-	}
-
 	if makeImage {
 		// The bootloader starts at 0x1000, or 4096.
 		// TinyGo doesn't use a separate bootloader and runs the entire
@@ -168,24 +100,11 @@ func makeESPFirmwareImage(infile, outfile, format string) error {
 	chip_id := map[string]uint16{
 		"esp32":   0x0000,
 		"esp32c3": 0x0005,
-		"esp32c6": 0x000d,
-		"esp32s3": 0x0009,
-	}[chip]
-
-	// SPI flash speed/size byte (byte 3 of header):
-	//   Upper nibble = flash size, lower nibble = flash frequency.
-	//   The espflasher auto-detects and patches the flash size (upper nibble),
-	//   but the frequency (lower nibble) must be correct per chip.
-	spiSpeedSize := map[string]uint8{
-		"esp32":   0x1f, // 80MHz=0x0F, 2MB=0x10
-		"esp32c3": 0x1f, // 80MHz=0x0F, 2MB=0x10
-		"esp32c6": 0x10, // 80MHz=0x00, 2MB=0x10 (C6 uses different freq encoding)
-		"esp32s3": 0x1f, // 80MHz=0x0F, 2MB=0x10
 	}[chip]
 
 	// Image header.
 	switch chip {
-	case "esp32", "esp32c3", "esp32s3", "esp32c6":
+	case "esp32", "esp32c3":
 		// Header format:
 		// https://github.com/espressif/esp-idf/blob/v4.3/components/bootloader_support/include/esp_app_format.h#L71
 		// Note: not adding a SHA256 hash as the binary is modified by
@@ -206,8 +125,8 @@ func makeESPFirmwareImage(infile, outfile, format string) error {
 		}{
 			magic:          0xE9,
 			segment_count:  byte(len(segments)),
-			spi_mode:       2, // ESP_IMAGE_SPI_MODE_DIO
-			spi_speed_size: spiSpeedSize,
+			spi_mode:       2,    // ESP_IMAGE_SPI_MODE_DIO
+			spi_speed_size: 0x1f, // ESP_IMAGE_SPI_SPEED_80M, ESP_IMAGE_FLASH_SIZE_2MB
 			entry_addr:     uint32(inf.Entry),
 			wp_pin:         0xEE, // disable WP pin
 			chip_id:        chip_id,
@@ -259,64 +178,6 @@ func makeESPFirmwareImage(infile, outfile, format string) error {
 		outf.Write(hash[:])
 	}
 
-	// For ESP32: append flash-mapped segments (DROM/IROM) at page-aligned flash
-	// offsets after the RAM portion. The startup code maps them via the flash
-	// cache MMU (DROM at esp32DromFlashAddr, patched into _drom_flash_addr).
-	if len(flashSegments) > 0 {
-		const flashBase = esp32FlashBase
-		const pageSize = esp32PageSize
-		dromFlashAddr := esp32DromFlashAddr
-
-		// Separate DROM and IROM segments.
-		var dromSegs, iromSegs []*espImageSegment
-		for _, seg := range flashSegments {
-			if seg.addr >= 0x3F400000 && seg.addr < 0x3F800000 {
-				dromSegs = append(dromSegs, seg)
-			} else {
-				iromSegs = append(iromSegs, seg)
-			}
-		}
-
-		// Write DROM segments at the computed page-aligned flash offset.
-		dromSize := 0
-		if len(dromSegs) > 0 {
-			targetImageOffset := int(dromFlashAddr - flashBase)
-			if makeImage {
-				targetImageOffset = int(dromFlashAddr)
-			}
-			if outf.Len() > targetImageOffset {
-				return fmt.Errorf("ESP32: RAM segments too large (%d bytes), overlap DROM at flash 0x%x", outf.Len(), dromFlashAddr)
-			}
-			outf.Write(make([]byte, targetImageOffset-outf.Len()))
-			for _, seg := range dromSegs {
-				outf.Write(seg.data)
-				dromSize += len(seg.data)
-			}
-		}
-
-		// Write IROM segments immediately after DROM, at the next page boundary.
-		// IROM flash addr = dromFlashAddr + ceil(dromSize/pageSize)*pageSize
-		// (must match the computation in the startup assembly).
-		if len(iromSegs) > 0 {
-			dromPages := (dromSize + pageSize - 1) / pageSize
-			if dromPages == 0 {
-				dromPages = 1
-			}
-			iromFlashAddr := dromFlashAddr + uint32(dromPages)*pageSize
-			targetImageOffset := int(iromFlashAddr - flashBase)
-			if makeImage {
-				targetImageOffset = int(iromFlashAddr)
-			}
-			if outf.Len() > targetImageOffset {
-				return fmt.Errorf("ESP32: DROM too large, overlaps IROM at flash 0x%x", iromFlashAddr)
-			}
-			outf.Write(make([]byte, targetImageOffset-outf.Len()))
-			for _, seg := range iromSegs {
-				outf.Write(seg.data)
-			}
-		}
-	}
-
 	// QEMU (or more precisely, qemu-system-xtensa from Espressif) expects the
 	// image to be a certain size.
 	if makeImage {

builder/jobs.go

@@ -195,11 +195,11 @@ type intHeap struct {
 	sort.IntSlice
 }
 
-func (h *intHeap) Push(x any) {
+func (h *intHeap) Push(x interface{}) {
 	h.IntSlice = append(h.IntSlice, x.(int))
 }
 
-func (h *intHeap) Pop() any {
+func (h *intHeap) Pop() interface{} {
 	x := h.IntSlice[len(h.IntSlice)-1]
 	h.IntSlice = h.IntSlice[:len(h.IntSlice)-1]
 	return x

builder/library.go

@@ -15,9 +15,6 @@ import (
 
 // Library is a container for information about a single C library, such as a
 // compiler runtime or libc.
-//
-// Note: whenever a library gets changed, the version in compileopts/config.go
-// probably also needs to be incremented.
 type Library struct {
 	// The library name, such as compiler-rt or picolibc.
 	name string
@@ -28,17 +25,11 @@ type Library struct {
 	// cflags returns the C flags specific to this library
 	cflags func(target, headerPath string) []string
 
-	// cflagsForFile returns additional C flags for a particular source file.
-	cflagsForFile func(path string) []string
-
-	// needsLibc is set to true if this library needs libc headers.
-	needsLibc bool
-
 	// The source directory.
 	sourceDir func() string
 
 	// The source files, relative to sourceDir.
-	librarySources func(target string, libcNeedsMalloc bool) ([]string, error)
+	librarySources func(target string) ([]string, error)
 
 	// The source code for the crt1.o file, relative to sourceDir.
 	crt1Source string
@@ -53,8 +44,13 @@ type Library struct {
 // As a side effect, this call creates the library header files if they didn't
 // exist yet.
 func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJob, abortLock func(), err error) {
-	outdir := config.LibraryPath(l.name)
+	outdir, precompiled := config.LibcPath(l.name)
 	archiveFilePath := filepath.Join(outdir, "lib.a")
+	if precompiled {
+		// Found a precompiled library for this OS/architecture. Return the path
+		// directly.
+		return dummyCompileJob(archiveFilePath), func() {}, nil
+	}
 
 	// Create a lock on the output (if supported).
 	// This is a bit messy, but avoids a deadlock because it is ordered consistently with other library loads within a build.
@@ -133,7 +129,7 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 	// Note: -fdebug-prefix-map is necessary to make the output archive
 	// reproducible. Otherwise the temporary directory is stored in the archive
 	// itself, which varies each run.
-	args := append(l.cflags(target, headerPath), "-c", "-Oz", "-gdwarf-4", "-ffunction-sections", "-fdata-sections", "-Wno-macro-redefined", "--target="+compileopts.ClangTriple(target), "-fdebug-prefix-map="+dir+"="+remapDir)
+	args := append(l.cflags(target, headerPath), "-c", "-Oz", "-gdwarf-4", "-ffunction-sections", "-fdata-sections", "-Wno-macro-redefined", "--target="+target, "-fdebug-prefix-map="+dir+"="+remapDir)
 	resourceDir := goenv.ClangResourceDir(false)
 	if resourceDir != "" {
 		args = append(args, "-resource-dir="+resourceDir)
@@ -167,9 +163,9 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 		// double.
 		args = append(args, "-mdouble=64")
 	case "riscv32":
-		args = append(args, "-march="+riscvMarch(config, "rv32imac"), "-fforce-enable-int128")
+		args = append(args, "-march=rv32imac", "-fforce-enable-int128")
 	case "riscv64":
-		args = append(args, "-march="+riscvMarch(config, "rv64gc"))
+		args = append(args, "-march=rv64gc")
 	case "mips":
 		args = append(args, "-fno-pic")
 	}
@@ -185,9 +181,6 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 			args = append(args, "-mfpu=vfpv2")
 		}
 	}
-	if l.needsLibc {
-		args = append(args, config.LibcCFlags()...)
-	}
 
 	var once sync.Once
 
@@ -218,7 +211,7 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 				return err
 			}
 			// Store this archive in the cache.
-			return robustRename(f.Name(), archiveFilePath)
+			return os.Rename(f.Name(), archiveFilePath)
 		},
 	}
 
@@ -226,7 +219,7 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 
 	// Create jobs to compile all sources. These jobs are depended upon by the
 	// archive job above, so must be run first.
-	paths, err := l.librarySources(target, config.LibcNeedsMalloc())
+	paths, err := l.librarySources(target)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -240,14 +233,11 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 		objpath := filepath.Join(dir, cleanpath+".o")
 		os.MkdirAll(filepath.Dir(objpath), 0o777)
 		objs = append(objs, objpath)
-		objfile := &compileJob{
+		job.dependencies = append(job.dependencies, &compileJob{
 			description: "compile " + srcpath,
 			run: func(*compileJob) error {
 				var compileArgs []string
 				compileArgs = append(compileArgs, args...)
-				if l.cflagsForFile != nil {
-					compileArgs = append(compileArgs, l.cflagsForFile(path)...)
-				}
 				compileArgs = append(compileArgs, "-o", objpath, srcpath)
 				if config.Options.PrintCommands != nil {
 					config.Options.PrintCommands("clang", compileArgs...)
@@ -258,8 +248,7 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 				}
 				return nil
 			},
-		}
-		job.dependencies = append(job.dependencies, objfile)
+		})
 	}
 
 	// Create crt1.o job, if needed.
@@ -268,7 +257,7 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 	// won't make much of a difference in speed).
 	if l.crt1Source != "" {
 		srcpath := filepath.Join(sourceDir, l.crt1Source)
-		crt1Job := &compileJob{
+		job.dependencies = append(job.dependencies, &compileJob{
 			description: "compile " + srcpath,
 			run: func(*compileJob) error {
 				var compileArgs []string
@@ -288,8 +277,7 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 				}
 				return os.Rename(tmpfile.Name(), filepath.Join(outdir, "crt1.o"))
 			},
-		}
-		job.dependencies = append(job.dependencies, crt1Job)
+		})
 	}
 
 	ok = true
@@ -297,17 +285,3 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 		once.Do(unlock)
 	}, nil
 }
-
-// riscvMarch returns the -march value for RISC-V library compilation.
-// It extracts the value from the target's cflags if present, otherwise
-// falls back to the provided default. This ensures libraries are compiled
-// with the correct ISA extensions for each target (e.g. rv32imc for
-// ESP32-C3 which lacks the atomic extension).
-func riscvMarch(config *compileopts.Config, defaultMarch string) string {
-	for _, flag := range config.Target.CFlags {
-		if strings.HasPrefix(flag, "-march=") {
-			return flag[len("-march="):]
-		}
-	}
-	return defaultMarch
-}

builder/mingw-w64.go

@@ -30,62 +30,25 @@ var libMinGW = Library{
 	sourceDir: func() string { return filepath.Join(goenv.Get("TINYGOROOT"), "lib/mingw-w64") },
 	cflags: func(target, headerPath string) []string {
 		mingwDir := filepath.Join(goenv.Get("TINYGOROOT"), "lib/mingw-w64")
-		flags := []string{
+		return []string{
 			"-nostdlibinc",
-			"-isystem", mingwDir + "/mingw-w64-crt/include",
 			"-isystem", mingwDir + "/mingw-w64-headers/crt",
-			"-isystem", mingwDir + "/mingw-w64-headers/include",
 			"-I", mingwDir + "/mingw-w64-headers/defaults/include",
 			"-I" + headerPath,
 		}
-		if strings.Split(target, "-")[0] == "i386" {
-			flags = append(flags,
-				"-D__MSVCRT_VERSION__=0x700", // Microsoft Visual C++ .NET 2002
-				"-D_WIN32_WINNT=0x0501",      // target Windows XP
-				"-D_CRTBLD",
-				"-Wno-pragma-pack",
-			)
-		}
-		return flags
 	},
-	librarySources: func(target string, _ bool) ([]string, error) {
+	librarySources: func(target string) ([]string, error) {
 		// These files are needed so that printf and the like are supported.
-		var sources []string
-		if strings.Split(target, "-")[0] == "i386" {
-			// Old 32-bit x86 systems use msvcrt.dll.
-			sources = []string{
-				"mingw-w64-crt/crt/pseudo-reloc.c",
-				"mingw-w64-crt/gdtoa/dmisc.c",
-				"mingw-w64-crt/gdtoa/gdtoa.c",
-				"mingw-w64-crt/gdtoa/gmisc.c",
-				"mingw-w64-crt/gdtoa/misc.c",
-				"mingw-w64-crt/math/x86/exp2.S",
-				"mingw-w64-crt/math/x86/trunc.S",
-				"mingw-w64-crt/misc/___mb_cur_max_func.c",
-				"mingw-w64-crt/misc/lc_locale_func.c",
-				"mingw-w64-crt/misc/mbrtowc.c",
-				"mingw-w64-crt/misc/strnlen.c",
-				"mingw-w64-crt/misc/wcrtomb.c",
-				"mingw-w64-crt/misc/wcsnlen.c",
-				"mingw-w64-crt/stdio/acrt_iob_func.c",
-				"mingw-w64-crt/stdio/mingw_lock.c",
-				"mingw-w64-crt/stdio/mingw_pformat.c",
-				"mingw-w64-crt/stdio/mingw_vfprintf.c",
-				"mingw-w64-crt/stdio/mingw_vsnprintf.c",
-			}
-		} else {
-			// Anything somewhat modern (amd64, arm64) uses UCRT.
-			sources = []string{
-				"mingw-w64-crt/stdio/ucrt_fprintf.c",
-				"mingw-w64-crt/stdio/ucrt_fwprintf.c",
-				"mingw-w64-crt/stdio/ucrt_printf.c",
-				"mingw-w64-crt/stdio/ucrt_snprintf.c",
-				"mingw-w64-crt/stdio/ucrt_sprintf.c",
-				"mingw-w64-crt/stdio/ucrt_vfprintf.c",
-				"mingw-w64-crt/stdio/ucrt_vprintf.c",
-				"mingw-w64-crt/stdio/ucrt_vsnprintf.c",
-				"mingw-w64-crt/stdio/ucrt_vsprintf.c",
-			}
+		sources := []string{
+			"mingw-w64-crt/stdio/ucrt_fprintf.c",
+			"mingw-w64-crt/stdio/ucrt_fwprintf.c",
+			"mingw-w64-crt/stdio/ucrt_printf.c",
+			"mingw-w64-crt/stdio/ucrt_snprintf.c",
+			"mingw-w64-crt/stdio/ucrt_sprintf.c",
+			"mingw-w64-crt/stdio/ucrt_vfprintf.c",
+			"mingw-w64-crt/stdio/ucrt_vprintf.c",
+			"mingw-w64-crt/stdio/ucrt_vsnprintf.c",
+			"mingw-w64-crt/stdio/ucrt_vsprintf.c",
 		}
 		return sources, nil
 	},
@@ -100,41 +63,27 @@ var libMinGW = Library{
 func makeMinGWExtraLibs(tmpdir, goarch string) []*compileJob {
 	var jobs []*compileJob
 	root := goenv.Get("TINYGOROOT")
-	var libs []string
-	if goarch == "386" {
-		libs = []string{
-			// x86 uses msvcrt.dll instead of UCRT for compatibility with old
-			// Windows versions.
-			"advapi32.def.in",
-			"kernel32.def.in",
-			"msvcrt.def.in",
-		}
-	} else {
-		// Use the modernized UCRT on new systems.
-		// Normally all the api-ms-win-crt-*.def files are all compiled to a
-		// single .lib file. But to simplify things, we're going to leave them
-		// as separate files.
-		libs = []string{
-			"advapi32.def.in",
-			"kernel32.def.in",
-			"api-ms-win-crt-conio-l1-1-0.def",
-			"api-ms-win-crt-convert-l1-1-0.def.in",
-			"api-ms-win-crt-environment-l1-1-0.def",
-			"api-ms-win-crt-filesystem-l1-1-0.def",
-			"api-ms-win-crt-heap-l1-1-0.def",
-			"api-ms-win-crt-locale-l1-1-0.def",
-			"api-ms-win-crt-math-l1-1-0.def.in",
-			"api-ms-win-crt-multibyte-l1-1-0.def",
-			"api-ms-win-crt-private-l1-1-0.def.in",
-			"api-ms-win-crt-process-l1-1-0.def",
-			"api-ms-win-crt-runtime-l1-1-0.def.in",
-			"api-ms-win-crt-stdio-l1-1-0.def",
-			"api-ms-win-crt-string-l1-1-0.def",
-			"api-ms-win-crt-time-l1-1-0.def",
-			"api-ms-win-crt-utility-l1-1-0.def",
-		}
-	}
-	for _, name := range libs {
+	// Normally all the api-ms-win-crt-*.def files are all compiled to a single
+	// .lib file. But to simplify things, we're going to leave them as separate
+	// files.
+	for _, name := range []string{
+		"kernel32.def.in",
+		"api-ms-win-crt-conio-l1-1-0.def",
+		"api-ms-win-crt-convert-l1-1-0.def.in",
+		"api-ms-win-crt-environment-l1-1-0.def",
+		"api-ms-win-crt-filesystem-l1-1-0.def",
+		"api-ms-win-crt-heap-l1-1-0.def",
+		"api-ms-win-crt-locale-l1-1-0.def",
+		"api-ms-win-crt-math-l1-1-0.def.in",
+		"api-ms-win-crt-multibyte-l1-1-0.def",
+		"api-ms-win-crt-private-l1-1-0.def.in",
+		"api-ms-win-crt-process-l1-1-0.def",
+		"api-ms-win-crt-runtime-l1-1-0.def.in",
+		"api-ms-win-crt-stdio-l1-1-0.def",
+		"api-ms-win-crt-string-l1-1-0.def",
+		"api-ms-win-crt-time-l1-1-0.def",
+		"api-ms-win-crt-utility-l1-1-0.def",
+	} {
 		outpath := filepath.Join(tmpdir, filepath.Base(name)+".lib")
 		inpath := filepath.Join(root, "lib/mingw-w64/mingw-w64-crt/lib-common/"+name)
 		job := &compileJob{
@@ -144,9 +93,6 @@ func makeMinGWExtraLibs(tmpdir, goarch string) []*compileJob {
 				defpath := inpath
 				var archDef, emulation string
 				switch goarch {
-				case "386":
-					archDef = "-DDEF_I386"
-					emulation = "i386pe"
 				case "amd64":
 					archDef = "-DDEF_X64"
 					emulation = "i386pep"

builder/musl.go

@@ -12,45 +12,6 @@ import (
 	"github.com/tinygo-org/tinygo/goenv"
 )
 
-// Create the alltypes.h file from the appropriate alltypes.h.in files.
-func buildMuslAllTypes(arch, muslDir, outputBitsDir string) error {
-	// Create the file alltypes.h.
-	f, err := os.Create(filepath.Join(outputBitsDir, "alltypes.h"))
-	if err != nil {
-		return err
-	}
-	infiles := []string{
-		filepath.Join(muslDir, "arch", arch, "bits", "alltypes.h.in"),
-		filepath.Join(muslDir, "include", "alltypes.h.in"),
-	}
-	for _, infile := range infiles {
-		data, err := os.ReadFile(infile)
-		if err != nil {
-			return err
-		}
-		lines := strings.SplitSeq(string(data), "\n")
-		for line := range lines {
-			if strings.HasPrefix(line, "TYPEDEF ") {
-				matches := regexp.MustCompile(`TYPEDEF (.*) ([^ ]*);`).FindStringSubmatch(line)
-				value := matches[1]
-				name := matches[2]
-				line = fmt.Sprintf("#if defined(__NEED_%s) && !defined(__DEFINED_%s)\ntypedef %s %s;\n#define __DEFINED_%s\n#endif\n", name, name, value, name, name)
-			}
-			if strings.HasPrefix(line, "STRUCT ") {
-				matches := regexp.MustCompile(`STRUCT * ([^ ]*) (.*);`).FindStringSubmatch(line)
-				name := matches[1]
-				value := matches[2]
-				line = fmt.Sprintf("#if defined(__NEED_struct_%s) && !defined(__DEFINED_struct_%s)\nstruct %s %s;\n#define __DEFINED_struct_%s\n#endif\n", name, name, name, value, name)
-			}
-			_, err := f.WriteString(line + "\n")
-			if err != nil {
-				return err
-			}
-		}
-	}
-	return f.Close()
-}
-
 var libMusl = Library{
 	name: "musl",
 	makeHeaders: func(target, includeDir string) error {
@@ -63,13 +24,41 @@ var libMusl = Library{
 		arch := compileopts.MuslArchitecture(target)
 		muslDir := filepath.Join(goenv.Get("TINYGOROOT"), "lib", "musl")
 
-		err = buildMuslAllTypes(arch, muslDir, bits)
+		// Create the file alltypes.h.
+		f, err := os.Create(filepath.Join(bits, "alltypes.h"))
 		if err != nil {
 			return err
 		}
+		infiles := []string{
+			filepath.Join(muslDir, "arch", arch, "bits", "alltypes.h.in"),
+			filepath.Join(muslDir, "include", "alltypes.h.in"),
+		}
+		for _, infile := range infiles {
+			data, err := os.ReadFile(infile)
+			if err != nil {
+				return err
+			}
+			lines := strings.Split(string(data), "\n")
+			for _, line := range lines {
+				if strings.HasPrefix(line, "TYPEDEF ") {
+					matches := regexp.MustCompile(`TYPEDEF (.*) ([^ ]*);`).FindStringSubmatch(line)
+					value := matches[1]
+					name := matches[2]
+					line = fmt.Sprintf("#if defined(__NEED_%s) && !defined(__DEFINED_%s)\ntypedef %s %s;\n#define __DEFINED_%s\n#endif\n", name, name, value, name, name)
+				}
+				if strings.HasPrefix(line, "STRUCT ") {
+					matches := regexp.MustCompile(`STRUCT * ([^ ]*) (.*);`).FindStringSubmatch(line)
+					name := matches[1]
+					value := matches[2]
+					line = fmt.Sprintf("#if defined(__NEED_struct_%s) && !defined(__DEFINED_struct_%s)\nstruct %s %s;\n#define __DEFINED_struct_%s\n#endif\n", name, name, name, value, name)
+				}
+				f.WriteString(line + "\n")
+			}
+		}
+		f.Close()
 
 		// Create the file syscall.h.
-		f, err := os.Create(filepath.Join(bits, "syscall.h"))
+		f, err = os.Create(filepath.Join(bits, "syscall.h"))
 		if err != nil {
 			return err
 		}
@@ -121,36 +110,29 @@ var libMusl = Library{
 		return cflags
 	},
 	sourceDir: func() string { return filepath.Join(goenv.Get("TINYGOROOT"), "lib/musl/src") },
-	librarySources: func(target string, _ bool) ([]string, error) {
+	librarySources: func(target string) ([]string, error) {
 		arch := compileopts.MuslArchitecture(target)
 		globs := []string{
-			"conf/*.c",
-			"ctype/*.c",
 			"env/*.c",
 			"errno/*.c",
 			"exit/*.c",
 			"fcntl/*.c",
 			"internal/defsysinfo.c",
-			"internal/intscan.c",
 			"internal/libc.c",
-			"internal/shgetc.c",
 			"internal/syscall_ret.c",
 			"internal/vdso.c",
 			"legacy/*.c",
 			"locale/*.c",
 			"linux/*.c",
-			"locale/*.c",
 			"malloc/*.c",
 			"malloc/mallocng/*.c",
 			"mman/*.c",
 			"math/*.c",
 			"misc/*.c",
 			"multibyte/*.c",
-			"sched/*.c",
 			"signal/" + arch + "/*.s",
 			"signal/*.c",
 			"stdio/*.c",
-			"stdlib/*.c",
 			"string/*.c",
 			"thread/" + arch + "/*.s",
 			"thread/*.c",

builder/nrfutil.go

@@ -19,7 +19,7 @@ type jsonManifest struct {
 			DataFile       string        `json:"dat_file"`
 			InitPacketData nrfInitPacket `json:"init_packet_data"`
 		} `json:"application"`
-		DFUVersion float64 `json:"dfu_version"` // yes, this is a JSON number, not a string
+		DFUVersion float64 `json:"dfu_version,omitempty"` // yes, this is a JSON number, not a string
 	} `json:"manifest"`
 }
 
@@ -93,7 +93,19 @@ func makeDFUFirmwareImage(options *compileopts.Options, infile, outfile string)
 	manifest.Manifest.Application.BinaryFile = "application.bin"
 	manifest.Manifest.Application.DataFile = "application.dat"
 	manifest.Manifest.Application.InitPacketData = initPacket
-	manifest.Manifest.DFUVersion = 0.5
+
+	// use build tag "nrf_open_dfu" to indicate open DFU format, otherwise defaults to secure DFU
+	openDFU := false
+	for _, tag := range options.Tags {
+		if tag == "nrf_open_dfu" {
+			openDFU = true
+			break
+		}
+	}
+
+	if !openDFU {
+		manifest.Manifest.DFUVersion = 0.5
+	}
 
 	// Write the JSON manifest to the file.
 	jsonw, err := w.Create("manifest.json")

builder/picolibc.go

@@ -43,7 +43,7 @@ var libPicolibc = Library{
 		}
 	},
 	sourceDir: func() string { return filepath.Join(goenv.Get("TINYGOROOT"), "lib/picolibc/newlib") },
-	librarySources: func(target string, _ bool) ([]string, error) {
+	librarySources: func(target string) ([]string, error) {
 		sources := append([]string(nil), picolibcSources...)
 		if !strings.HasPrefix(target, "avr") {
 			// Small chips without long jumps can't compile many files (printf,

builder/robustio_other.go

@@ -1,9 +0,0 @@
-//go:build !windows
-
-package builder
-
-import "os"
-
-func robustRename(oldpath, newpath string) error {
-	return os.Rename(oldpath, newpath)
-}

builder/robustio_windows.go

@@ -1,44 +0,0 @@
-package builder
-
-import (
-	"errors"
-	"math/rand"
-	"os"
-	"syscall"
-	"time"
-)
-
-const robustRenameTimeout = 2 * time.Second
-
-func robustRename(oldpath, newpath string) error {
-	var bestErr error
-	start := time.Now()
-	nextSleep := time.Millisecond
-	for {
-		err := os.Rename(oldpath, newpath)
-		if err == nil || !isEphemeralRenameError(err) {
-			return err
-		}
-		if bestErr == nil {
-			bestErr = err
-		}
-		if d := time.Since(start) + nextSleep; d >= robustRenameTimeout {
-			return bestErr
-		}
-		time.Sleep(nextSleep)
-		nextSleep += time.Duration(rand.Int63n(int64(nextSleep)))
-	}
-}
-
-func isEphemeralRenameError(err error) bool {
-	var errno syscall.Errno
-	if errors.As(err, &errno) {
-		switch errno {
-		case syscall.Errno(2), // ERROR_FILE_NOT_FOUND
-			syscall.Errno(5),  // ERROR_ACCESS_DENIED
-			syscall.Errno(32): // ERROR_SHARING_VIOLATION
-			return true
-		}
-	}
-	return false
-}

builder/sizes.go

@@ -490,7 +490,7 @@ func loadProgramSize(path string, packagePathMap map[string]string) (*programSiz
 				continue
 			}
 			if section.Type == elf.SHT_NOBITS {
-				if strings.HasPrefix(section.Name, ".stack") {
+				if section.Name == ".stack" {
 					// TinyGo emits stack sections on microcontroller using the
 					// ".stack" name.
 					// This is a bit ugly, but I don't think there is a way to
@@ -501,9 +501,8 @@ func loadProgramSize(path string, packagePathMap map[string]string) (*programSiz
 						Align:   section.Addralign,
 						Type:    memoryStack,
 					})
-				} else if section.Flags&elf.SHF_WRITE != 0 {
-					// Regular .bss section. Zero-initialized RAM is always
-					// writable, so require SHF_WRITE here.
+				} else {
+					// Regular .bss section.
 					sections = append(sections, memorySection{
 						Address: section.Addr,
 						Size:    section.Size,
@@ -511,11 +510,6 @@ func loadProgramSize(path string, packagePathMap map[string]string) (*programSiz
 						Type:    memoryBSS,
 					})
 				}
-				// Other (non-writable) SHT_NOBITS sections are address-space
-				// placeholders that occupy no RAM, such as the ESP linker
-				// script's .irom_dummy / .rodata_dummy sections which reserve
-				// the flash-mapped XIP virtual address ranges. They must not be
-				// counted as bss/RAM usage.
 			} else if section.Type == elf.SHT_PROGBITS && section.Flags&elf.SHF_EXECINSTR != 0 {
 				// .text
 				sections = append(sections, memorySection{
@@ -960,11 +954,7 @@ func findPackagePath(path string, packagePathMap map[string]string) (packagePath
 			libPath := strings.TrimPrefix(path, filepath.Join(goenv.Get("TINYGOROOT"), "lib")+string(os.PathSeparator))
 			parts := strings.SplitN(libPath, string(os.PathSeparator), 2)
 			packagePath = "C " + parts[0]
-			if len(parts) > 1 {
-				filename = parts[1]
-			} else {
-				filename = parts[0]
-			}
+			filename = parts[1]
 		} else if prefix := filepath.Join(goenv.Get("TINYGOROOT"), "llvm-project", "compiler-rt"); strings.HasPrefix(path, prefix) {
 			packagePath = "C compiler-rt"
 			filename = strings.TrimPrefix(path, prefix+string(os.PathSeparator))

builder/sizes_test.go

@@ -1,13 +1,8 @@
 package builder
 
 import (
-	"flag"
-	"fmt"
-	"os"
 	"regexp"
 	"runtime"
-	"strconv"
-	"strings"
 	"testing"
 	"time"
 
@@ -16,19 +11,21 @@ import (
 
 var sema = make(chan struct{}, runtime.NumCPU())
 
-var flagUpdate = flag.Bool("update", false, "update builder package tests")
-
 type sizeTest struct {
-	target string
-	path   string
+	target     string
+	path       string
+	codeSize   uint64
+	rodataSize uint64
+	dataSize   uint64
+	bssSize    uint64
 }
 
 // Test whether code and data size is as expected for the given targets.
 // This tests both the logic of loadProgramSize and checks that code size
 // doesn't change unintentionally.
 //
-// If you find that code or data size is reduced, then great! You can update the
-// golden file by passing -update to the test.
+// If you find that code or data size is reduced, then great! You can reduce the
+// number in this test.
 // If you find that the code or data size is increased, take a look as to why
 // this is. It could be due to an update (LLVM version, Go version, etc) which
 // is fine, but it could also mean that a recent change introduced this size
@@ -45,110 +42,35 @@ func TestBinarySize(t *testing.T) {
 	// This is a small number of very diverse targets that we want to test.
 	tests := []sizeTest{
 		// microcontrollers
-		{"hifive1b", "examples/echo"},
-		{"microbit", "examples/serial"},
-		{"wioterminal", "examples/pininterrupt"},
+		{"hifive1b", "examples/echo", 4560, 280, 0, 2268},
+		{"microbit", "examples/serial", 2916, 388, 8, 2272},
+		{"wioterminal", "examples/pininterrupt", 7315, 1489, 116, 6912},
 
 		// TODO: also check wasm. Right now this is difficult, because
 		// wasm binaries are run through wasm-opt and therefore the
 		// output varies by binaryen version.
 	}
-	sizes := measureBinarySizes(t, tests)
-	output := formatSizeTable(tests, sizes)
-	checkGolden(t, "testdata/binary-size.txt", output)
-}
+	for _, tc := range tests {
+		tc := tc
+		t.Run(tc.target+"/"+tc.path, func(t *testing.T) {
+			t.Parallel()
 
-func checkGolden(t *testing.T, path, actual string) {
-	t.Helper()
-	if *flagUpdate {
-		if err := os.WriteFile(path, []byte(actual), 0o666); err != nil {
-			t.Fatal("failed to write updated golden file:", err)
-		}
-		return
-	}
-	expected, err := os.ReadFile(path)
-	if err != nil {
-		t.Fatal("failed to read golden file:", err)
-	}
-	if actual != string(expected) {
-		t.Errorf("%s does not match expected output (re-run with -update to regenerate):\nexpected:\n%sactual:\n%s", path, expected, actual)
-	}
-}
+			// Build the binary.
+			result := buildBinary(t, tc.target, tc.path)
 
-func measureBinarySizes(t *testing.T, tests []sizeTest) []*programSize {
-	t.Helper()
-	type result struct {
-		index int
-		size  *programSize
-		err   error
+			// Check whether the size of the binary matches the expected size.
+			sizes, err := loadProgramSize(result.Executable, nil)
+			if err != nil {
+				t.Fatal("could not read program size:", err)
+			}
+			if sizes.Code != tc.codeSize || sizes.ROData != tc.rodataSize || sizes.Data != tc.dataSize || sizes.BSS != tc.bssSize {
+				t.Errorf("Unexpected code size when compiling: -target=%s %s", tc.target, tc.path)
+				t.Errorf("            code rodata   data    bss")
+				t.Errorf("expected: %6d %6d %6d %6d", tc.codeSize, tc.rodataSize, tc.dataSize, tc.bssSize)
+				t.Errorf("actual:   %6d %6d %6d %6d", sizes.Code, sizes.ROData, sizes.Data, sizes.BSS)
+			}
+		})
 	}
-
-	results := make(chan result, len(tests))
-	for i, tc := range tests {
-		tmpdir := t.TempDir()
-		go func() {
-			size, err := measureBinarySize(tc, tmpdir)
-			results <- result{i, size, err}
-		}()
-	}
-
-	sizes := make([]*programSize, len(tests))
-	failed := false
-	for range tests {
-		result := <-results
-		if result.err != nil {
-			tc := tests[result.index]
-			t.Errorf("%s/%s: %v", tc.target, tc.path, result.err)
-			failed = true
-		}
-		sizes[result.index] = result.size
-	}
-	if failed {
-		t.FailNow()
-	}
-	return sizes
-}
-
-func measureBinarySize(tc sizeTest, tmpdir string) (*programSize, error) {
-	result, err := buildBinaryInDir(tc.target, tc.path, tmpdir)
-	if err != nil {
-		return nil, err
-	}
-	size, err := loadProgramSize(result.Executable, nil)
-	if err != nil {
-		return nil, fmt.Errorf("could not read program size: %w", err)
-	}
-	return size, nil
-}
-
-func formatSizeTable(tests []sizeTest, sizes []*programSize) string {
-	targetWidth := len("target")
-	packageWidth := len("package")
-	codeWidth := len("code")
-	rodataWidth := len("rodata")
-	dataWidth := len("data")
-	bssWidth := len("bss")
-	for i, tc := range tests {
-		targetWidth = max(targetWidth, len(tc.target))
-		packageWidth = max(packageWidth, len(tc.path))
-		codeWidth = max(codeWidth, len(strconv.FormatUint(sizes[i].Code, 10)))
-		rodataWidth = max(rodataWidth, len(strconv.FormatUint(sizes[i].ROData, 10)))
-		dataWidth = max(dataWidth, len(strconv.FormatUint(sizes[i].Data, 10)))
-		bssWidth = max(bssWidth, len(strconv.FormatUint(sizes[i].BSS, 10)))
-	}
-
-	var output strings.Builder
-	fmt.Fprintf(&output, "%-*s %-*s %*s %*s %*s %*s\n",
-		targetWidth, "target", packageWidth, "package",
-		codeWidth, "code", rodataWidth, "rodata", dataWidth, "data", bssWidth, "bss")
-	for i, tc := range tests {
-		size := sizes[i]
-		fmt.Fprintf(&output, "%-*s %-*s %*d %*d %*d %*d\n",
-			targetWidth, tc.target, packageWidth, tc.path,
-			codeWidth, size.Code, rodataWidth, size.ROData,
-			dataWidth, size.Data, bssWidth, size.BSS)
-	}
-	return output.String()
 }
 
 // Check that the -size=full flag attributes binary size to the correct package
@@ -163,6 +85,7 @@ func TestSizeFull(t *testing.T) {
 	pkgMatch := regexp.MustCompile(`^[a-z/]+$`)    // example: "internal/task"
 
 	for _, target := range tests {
+		target := target
 		t.Run(target, func(t *testing.T) {
 			t.Parallel()
 
@@ -176,7 +99,7 @@ func TestSizeFull(t *testing.T) {
 				t.Fatal("could not read program size:", err)
 			}
 			for _, pkg := range sizes.sortedPackageNames() {
-				if pkg == "(padding)" || pkg == "(unknown)" || pkg == "Go types" {
+				if pkg == "(padding)" || pkg == "(unknown)" {
 					// TODO: correctly attribute all unknown binary size.
 					continue
 				}
@@ -193,15 +116,6 @@ func TestSizeFull(t *testing.T) {
 }
 
 func buildBinary(t *testing.T, targetString, pkgName string) BuildResult {
-	t.Helper()
-	result, err := buildBinaryInDir(targetString, pkgName, t.TempDir())
-	if err != nil {
-		t.Fatal(err)
-	}
-	return result
-}
-
-func buildBinaryInDir(targetString, pkgName, tmpdir string) (BuildResult, error) {
 	options := compileopts.Options{
 		Target:        targetString,
 		Opt:           "z",
@@ -212,15 +126,15 @@ func buildBinaryInDir(targetString, pkgName, tmpdir string) (BuildResult, error)
 	}
 	target, err := compileopts.LoadTarget(&options)
 	if err != nil {
-		return BuildResult{}, fmt.Errorf("could not load target: %w", err)
+		t.Fatal("could not load target:", err)
 	}
 	config := &compileopts.Config{
 		Options: &options,
 		Target:  target,
 	}
-	result, err := Build(pkgName, "", tmpdir, config)
+	result, err := Build(pkgName, "", t.TempDir(), config)
 	if err != nil {
-		return BuildResult{}, fmt.Errorf("could not build: %w", err)
+		t.Fatal("could not build:", err)
 	}
-	return result, nil
+	return result
 }

builder/testdata/binary-size.txt

@@ -1,4 +0,0 @@
-target      package               code rodata data  bss
-hifive1b    examples/echo         4321    323    0 2268
-microbit    examples/serial       2842    382    8 2264
-wioterminal examples/pininterrupt 8039   1665  132 7496

builder/tools-builtin.go

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

builder/tools.go

@@ -116,24 +116,18 @@ func parseLLDErrors(text string) error {
 		// This can happen in some cases like with CGo and //go:linkname tricker.
 		if matches := regexp.MustCompile(`^ld.lld(-[0-9]+)?: error: undefined symbol: (.*)\n`).FindStringSubmatch(message); matches != nil {
 			symbolName := matches[2]
-			for line := range strings.SplitSeq(message, "\n") {
+			for _, line := range strings.Split(message, "\n") {
 				matches := regexp.MustCompile(`referenced by .* \(((.*):([0-9]+))\)`).FindStringSubmatch(line)
 				if matches != nil {
 					parsedError = true
 					line, _ := strconv.Atoi(matches[3])
-					msg := "linker could not find symbol " + symbolName
-					switch symbolName {
-					case "runtime.alloc":
-						msg = "object allocated on the heap with -gc=none"
-					case "runtime.alloc_noheap":
-						msg = "object allocated on the heap in //go:noheap function"
-					}
+					// TODO: detect common mistakes like -gc=none?
 					linkErrors = append(linkErrors, scanner.Error{
 						Pos: token.Position{
 							Filename: matches[2],
 							Line:     line,
 						},
-						Msg: msg,
+						Msg: "linker could not find symbol " + symbolName,
 					})
 				}
 			}

builder/uf2.go

@@ -40,7 +40,7 @@ func convertBinToUF2(input []byte, targetAddr uint32, uf2FamilyID string) ([]byt
 	}
 	bl.SetNumBlocks(len(blocks))
 
-	for i := range blocks {
+	for i := 0; i < len(blocks); i++ {
 		bl.SetBlockNo(i)
 		bl.SetData(blocks[i])
 

builder/wasilibc.go

@@ -1,284 +0,0 @@
-package builder
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-
-	"github.com/tinygo-org/tinygo/goenv"
-)
-
-var libWasiLibc = Library{
-	name: "wasi-libc",
-	makeHeaders: func(target, includeDir string) error {
-		bits := filepath.Join(includeDir, "bits")
-		err := os.Mkdir(bits, 0777)
-		if err != nil {
-			return err
-		}
-
-		muslDir := filepath.Join(goenv.Get("TINYGOROOT"), "lib", "wasi-libc/libc-top-half/musl")
-		err = buildMuslAllTypes("wasm32", muslDir, bits)
-		if err != nil {
-			return err
-		}
-
-		// See MUSL_OMIT_HEADERS in the Makefile.
-		omitHeaders := map[string]struct{}{
-			"syslog.h":   {},
-			"wait.h":     {},
-			"ucontext.h": {},
-			"paths.h":    {},
-			"utmp.h":     {},
-			"utmpx.h":    {},
-			"lastlog.h":  {},
-			"elf.h":      {},
-			"link.h":     {},
-			"pwd.h":      {},
-			"shadow.h":   {},
-			"grp.h":      {},
-			"mntent.h":   {},
-			"netdb.h":    {},
-			"resolv.h":   {},
-			"pty.h":      {},
-			"dlfcn.h":    {},
-			"setjmp.h":   {},
-			"ulimit.h":   {},
-			"wordexp.h":  {},
-			"spawn.h":    {},
-			"termios.h":  {},
-			"libintl.h":  {},
-			"aio.h":      {},
-
-			"stdarg.h": {},
-			"stddef.h": {},
-
-			"pthread.h": {},
-		}
-
-		for _, glob := range [][2]string{
-			{"libc-bottom-half/headers/public/*.h", ""},
-			{"libc-bottom-half/headers/public/wasi/*.h", "wasi"},
-			{"libc-top-half/musl/arch/wasm32/bits/*.h", "bits"},
-			{"libc-top-half/musl/include/*.h", ""},
-			{"libc-top-half/musl/include/netinet/*.h", "netinet"},
-			{"libc-top-half/musl/include/sys/*.h", "sys"},
-		} {
-			matches, _ := filepath.Glob(filepath.Join(goenv.Get("TINYGOROOT"), "lib/wasi-libc", glob[0]))
-			outDir := filepath.Join(includeDir, glob[1])
-			os.MkdirAll(outDir, 0o777)
-			for _, match := range matches {
-				name := filepath.Base(match)
-				if _, ok := omitHeaders[name]; ok {
-					continue
-				}
-				data, err := os.ReadFile(match)
-				if err != nil {
-					return err
-				}
-				err = os.WriteFile(filepath.Join(outDir, name), data, 0o666)
-				if err != nil {
-					return err
-				}
-			}
-		}
-
-		return nil
-	},
-	cflags: func(target, headerPath string) []string {
-		libcDir := filepath.Join(goenv.Get("TINYGOROOT"), "lib/wasi-libc")
-		return []string{
-			"-Werror",
-			"-Wall",
-			"-std=gnu11",
-			"-nostdlibinc",
-			"-mnontrapping-fptoint", "-msign-ext", "-mbulk-memory",
-			"-Wno-null-pointer-arithmetic", "-Wno-unused-parameter", "-Wno-sign-compare", "-Wno-unused-variable", "-Wno-unused-function", "-Wno-ignored-attributes", "-Wno-missing-braces", "-Wno-ignored-pragmas", "-Wno-unused-but-set-variable", "-Wno-unknown-warning-option",
-			"-Wno-parentheses", "-Wno-shift-op-parentheses", "-Wno-bitwise-op-parentheses", "-Wno-logical-op-parentheses", "-Wno-string-plus-int", "-Wno-dangling-else", "-Wno-unknown-pragmas",
-			"-DNDEBUG",
-			"-D__wasilibc_printscan_no_long_double",
-			"-D__wasilibc_printscan_full_support_option=\"long double support is disabled\"",
-			"-DBULK_MEMORY_THRESHOLD=32", // default threshold in wasi-libc
-			"-isystem", headerPath,
-			"-I" + libcDir + "/libc-top-half/musl/src/include",
-			"-I" + libcDir + "/libc-top-half/musl/src/internal",
-			"-I" + libcDir + "/libc-top-half/musl/arch/wasm32",
-			"-I" + libcDir + "/libc-top-half/musl/arch/generic",
-			"-I" + libcDir + "/libc-top-half/headers/private",
-		}
-	},
-	cflagsForFile: func(path string) []string {
-		if strings.HasPrefix(path, "libc-bottom-half"+string(os.PathSeparator)) {
-			libcDir := filepath.Join(goenv.Get("TINYGOROOT"), "lib/wasi-libc")
-			return []string{
-				"-I" + libcDir + "/libc-bottom-half/headers/private",
-				"-I" + libcDir + "/libc-bottom-half/cloudlibc/src/include",
-				"-I" + libcDir + "/libc-bottom-half/cloudlibc/src",
-			}
-		}
-		return nil
-	},
-	sourceDir: func() string { return filepath.Join(goenv.Get("TINYGOROOT"), "lib/wasi-libc") },
-	librarySources: func(target string, libcNeedsMalloc bool) ([]string, error) {
-		type filePattern struct {
-			glob    string
-			exclude []string
-		}
-
-		// See: LIBC_TOP_HALF_MUSL_SOURCES in the Makefile
-		globs := []filePattern{
-			// Top half: mostly musl sources.
-			{glob: "libc-top-half/sources/*.c"},
-			{glob: "libc-top-half/musl/src/conf/*.c"},
-			{glob: "libc-top-half/musl/src/internal/*.c", exclude: []string{
-				"procfdname.c", "syscall.c", "syscall_ret.c", "vdso.c", "version.c",
-			}},
-			{glob: "libc-top-half/musl/src/locale/*.c", exclude: []string{
-				"dcngettext.c", "textdomain.c", "bind_textdomain_codeset.c"}},
-			{glob: "libc-top-half/musl/src/math/*.c", exclude: []string{
-				"__signbit.c", "__signbitf.c", "__signbitl.c",
-				"__fpclassify.c", "__fpclassifyf.c", "__fpclassifyl.c",
-				"ceilf.c", "ceil.c",
-				"floorf.c", "floor.c",
-				"truncf.c", "trunc.c",
-				"rintf.c", "rint.c",
-				"nearbyintf.c", "nearbyint.c",
-				"sqrtf.c", "sqrt.c",
-				"fabsf.c", "fabs.c",
-				"copysignf.c", "copysign.c",
-				"fminf.c", "fmaxf.c",
-				"fmin.c", "fmax.c,",
-			}},
-			{glob: "libc-top-half/musl/src/multibyte/*.c"},
-			{glob: "libc-top-half/musl/src/stdio/*.c", exclude: []string{
-				"vfwscanf.c", "vfwprintf.c", // long double is unsupported
-				"__lockfile.c", "flockfile.c", "funlockfile.c", "ftrylockfile.c",
-				"rename.c",
-				"tmpnam.c", "tmpfile.c", "tempnam.c",
-				"popen.c", "pclose.c",
-				"remove.c",
-				"gets.c"}},
-			{glob: "libc-top-half/musl/src/stdlib/*.c"},
-			{glob: "libc-top-half/musl/src/string/*.c", exclude: []string{
-				"strsignal.c"}},
-
-			// Bottom half: connect top half to WASI equivalents.
-			{glob: "libc-bottom-half/cloudlibc/src/libc/*/*.c"},
-			{glob: "libc-bottom-half/cloudlibc/src/libc/sys/*/*.c"},
-			{glob: "libc-bottom-half/sources/*.c"},
-		}
-
-		// We're using the Boehm GC, so we need a heap implementation in the libc.
-		if libcNeedsMalloc {
-			globs = append(globs, filePattern{glob: "dlmalloc/src/dlmalloc.c"})
-		}
-
-		// See: LIBC_TOP_HALF_MUSL_SOURCES in the Makefile
-		sources := []string{
-			"libc-top-half/musl/src/misc/a64l.c",
-			"libc-top-half/musl/src/misc/basename.c",
-			"libc-top-half/musl/src/misc/dirname.c",
-			"libc-top-half/musl/src/misc/ffs.c",
-			"libc-top-half/musl/src/misc/ffsl.c",
-			"libc-top-half/musl/src/misc/ffsll.c",
-			"libc-top-half/musl/src/misc/fmtmsg.c",
-			"libc-top-half/musl/src/misc/getdomainname.c",
-			"libc-top-half/musl/src/misc/gethostid.c",
-			"libc-top-half/musl/src/misc/getopt.c",
-			"libc-top-half/musl/src/misc/getopt_long.c",
-			"libc-top-half/musl/src/misc/getsubopt.c",
-			"libc-top-half/musl/src/misc/uname.c",
-			"libc-top-half/musl/src/misc/nftw.c",
-			"libc-top-half/musl/src/errno/strerror.c",
-			"libc-top-half/musl/src/network/htonl.c",
-			"libc-top-half/musl/src/network/htons.c",
-			"libc-top-half/musl/src/network/ntohl.c",
-			"libc-top-half/musl/src/network/ntohs.c",
-			"libc-top-half/musl/src/network/inet_ntop.c",
-			"libc-top-half/musl/src/network/inet_pton.c",
-			"libc-top-half/musl/src/network/inet_aton.c",
-			"libc-top-half/musl/src/network/in6addr_any.c",
-			"libc-top-half/musl/src/network/in6addr_loopback.c",
-			"libc-top-half/musl/src/fenv/fenv.c",
-			"libc-top-half/musl/src/fenv/fesetround.c",
-			"libc-top-half/musl/src/fenv/feupdateenv.c",
-			"libc-top-half/musl/src/fenv/fesetexceptflag.c",
-			"libc-top-half/musl/src/fenv/fegetexceptflag.c",
-			"libc-top-half/musl/src/fenv/feholdexcept.c",
-			"libc-top-half/musl/src/exit/exit.c",
-			"libc-top-half/musl/src/exit/atexit.c",
-			"libc-top-half/musl/src/exit/assert.c",
-			"libc-top-half/musl/src/exit/quick_exit.c",
-			"libc-top-half/musl/src/exit/at_quick_exit.c",
-			"libc-top-half/musl/src/time/strftime.c",
-			"libc-top-half/musl/src/time/asctime.c",
-			"libc-top-half/musl/src/time/asctime_r.c",
-			"libc-top-half/musl/src/time/ctime.c",
-			"libc-top-half/musl/src/time/ctime_r.c",
-			"libc-top-half/musl/src/time/wcsftime.c",
-			"libc-top-half/musl/src/time/strptime.c",
-			"libc-top-half/musl/src/time/difftime.c",
-			"libc-top-half/musl/src/time/timegm.c",
-			"libc-top-half/musl/src/time/ftime.c",
-			"libc-top-half/musl/src/time/gmtime.c",
-			"libc-top-half/musl/src/time/gmtime_r.c",
-			"libc-top-half/musl/src/time/timespec_get.c",
-			"libc-top-half/musl/src/time/getdate.c",
-			"libc-top-half/musl/src/time/localtime.c",
-			"libc-top-half/musl/src/time/localtime_r.c",
-			"libc-top-half/musl/src/time/mktime.c",
-			"libc-top-half/musl/src/time/__tm_to_secs.c",
-			"libc-top-half/musl/src/time/__month_to_secs.c",
-			"libc-top-half/musl/src/time/__secs_to_tm.c",
-			"libc-top-half/musl/src/time/__year_to_secs.c",
-			"libc-top-half/musl/src/time/__tz.c",
-			"libc-top-half/musl/src/fcntl/creat.c",
-			"libc-top-half/musl/src/dirent/alphasort.c",
-			"libc-top-half/musl/src/dirent/versionsort.c",
-			"libc-top-half/musl/src/env/__stack_chk_fail.c",
-			"libc-top-half/musl/src/env/clearenv.c",
-			"libc-top-half/musl/src/env/getenv.c",
-			"libc-top-half/musl/src/env/putenv.c",
-			"libc-top-half/musl/src/env/setenv.c",
-			"libc-top-half/musl/src/env/unsetenv.c",
-			"libc-top-half/musl/src/unistd/posix_close.c",
-			"libc-top-half/musl/src/stat/futimesat.c",
-			"libc-top-half/musl/src/legacy/getpagesize.c",
-			"libc-top-half/musl/src/thread/thrd_sleep.c",
-		}
-
-		basepath := goenv.Get("TINYGOROOT") + "/lib/wasi-libc/"
-		for _, pattern := range globs {
-			matches, err := filepath.Glob(basepath + pattern.glob)
-			if err != nil {
-				// From the documentation:
-				// > Glob ignores file system errors such as I/O errors reading
-				// > directories. The only possible returned error is
-				// > ErrBadPattern, when pattern is malformed.
-				// So the only possible error is when the (statically defined)
-				// pattern is wrong. In other words, a programming bug.
-				return nil, fmt.Errorf("wasi-libc: could not glob source dirs: %w", err)
-			}
-			if len(matches) == 0 {
-				return nil, fmt.Errorf("wasi-libc: did not find any files for pattern %#v", pattern)
-			}
-			excludeSet := map[string]struct{}{}
-			for _, exclude := range pattern.exclude {
-				excludeSet[exclude] = struct{}{}
-			}
-			for _, match := range matches {
-				if _, ok := excludeSet[filepath.Base(match)]; ok {
-					continue
-				}
-				relpath, err := filepath.Rel(basepath, match)
-				if err != nil {
-					// Not sure if this is even possible.
-					return nil, err
-				}
-				sources = append(sources, relpath)
-			}
-		}
-		return sources, nil
-	},
-}

builder/wasmbuiltins.go

@@ -29,8 +29,6 @@ var libWasmBuiltins = Library{
 			"-Wall",
 			"-std=gnu11",
 			"-nostdlibinc",
-			"-mnontrapping-fptoint", // match wasm-unknown (default on in LLVM 20)
-			"-mno-bulk-memory",      // same here
 			"-isystem", libcDir + "/libc-top-half/musl/arch/wasm32",
 			"-isystem", libcDir + "/libc-top-half/musl/arch/generic",
 			"-isystem", libcDir + "/libc-top-half/musl/src/internal",
@@ -41,7 +39,7 @@ var libWasmBuiltins = Library{
 		}
 	},
 	sourceDir: func() string { return filepath.Join(goenv.Get("TINYGOROOT"), "lib/wasi-libc") },
-	librarySources: func(target string, _ bool) ([]string, error) {
+	librarySources: func(target string) ([]string, error) {
 		return []string{
 			// memory builtins needed for llvm.memcpy.*, llvm.memmove.*, and
 			// llvm.memset.* LLVM intrinsics.

cgo/cgo.go

@@ -26,6 +26,10 @@ import (
 	"golang.org/x/tools/go/ast/astutil"
 )
 
+// Function that's only defined in Go 1.22.
+var setASTFileFields = func(f *ast.File, start, end token.Pos) {
+}
+
 // cgoPackage holds all CGo-related information of a package.
 type cgoPackage struct {
 	generated       *ast.File
@@ -40,7 +44,7 @@ type cgoPackage struct {
 	tokenFiles      map[string]*token.File
 	definedGlobally map[string]ast.Node
 	noescapingFuncs map[string]*noescapingFunc // #cgo noescape lines
-	anonDecls       map[any]string
+	anonDecls       map[interface{}]string
 	cflags          []string // CFlags from #cgo lines
 	ldflags         []string // LDFlags from #cgo lines
 	visitedFiles    map[string][]byte
@@ -88,18 +92,18 @@ type noescapingFunc struct {
 // cgoAliases list type aliases between Go and C, for types that are equivalent
 // in both languages. See addTypeAliases.
 var cgoAliases = map[string]string{
-	"_Cgo_int8_t":    "int8",
-	"_Cgo_int16_t":   "int16",
-	"_Cgo_int32_t":   "int32",
-	"_Cgo_int64_t":   "int64",
-	"_Cgo_uint8_t":   "uint8",
-	"_Cgo_uint16_t":  "uint16",
-	"_Cgo_uint32_t":  "uint32",
-	"_Cgo_uint64_t":  "uint64",
-	"_Cgo_uintptr_t": "uintptr",
-	"_Cgo_float":     "float32",
-	"_Cgo_double":    "float64",
-	"_Cgo__Bool":     "bool",
+	"C.int8_t":    "int8",
+	"C.int16_t":   "int16",
+	"C.int32_t":   "int32",
+	"C.int64_t":   "int64",
+	"C.uint8_t":   "uint8",
+	"C.uint16_t":  "uint16",
+	"C.uint32_t":  "uint32",
+	"C.uint64_t":  "uint64",
+	"C.uintptr_t": "uintptr",
+	"C.float":     "float32",
+	"C.double":    "float64",
+	"C._Bool":     "bool",
 }
 
 // builtinAliases are handled specially because they only exist on the Go side
@@ -141,46 +145,48 @@ typedef unsigned long long  _Cgo_ulonglong;
 // The string/bytes functions below implement C.CString etc. To make sure the
 // runtime doesn't need to know the C int type, lengths are converted to uintptr
 // first.
+// These functions will be modified to get a "C." prefix, so the source below
+// doesn't reflect the final AST.
 const generatedGoFilePrefixBase = `
 import "syscall"
 import "unsafe"
 
 var _ unsafe.Pointer
 
-//go:linkname _Cgo_CString runtime.cgo_CString
-func _Cgo_CString(string) *_Cgo_char
+//go:linkname C.CString runtime.cgo_CString
+func CString(string) *C.char
 
-//go:linkname _Cgo_GoString runtime.cgo_GoString
-func _Cgo_GoString(*_Cgo_char) string
+//go:linkname C.GoString runtime.cgo_GoString
+func GoString(*C.char) string
 
-//go:linkname _Cgo___GoStringN runtime.cgo_GoStringN
-func _Cgo___GoStringN(*_Cgo_char, uintptr) string
+//go:linkname C.__GoStringN runtime.cgo_GoStringN
+func __GoStringN(*C.char, uintptr) string
 
-func _Cgo_GoStringN(cstr *_Cgo_char, length _Cgo_int) string {
-	return _Cgo___GoStringN(cstr, uintptr(length))
+func GoStringN(cstr *C.char, length C.int) string {
+	return C.__GoStringN(cstr, uintptr(length))
 }
 
-//go:linkname _Cgo___GoBytes runtime.cgo_GoBytes
-func _Cgo___GoBytes(unsafe.Pointer, uintptr) []byte
+//go:linkname C.__GoBytes runtime.cgo_GoBytes
+func __GoBytes(unsafe.Pointer, uintptr) []byte
 
-func _Cgo_GoBytes(ptr unsafe.Pointer, length _Cgo_int) []byte {
-	return _Cgo___GoBytes(ptr, uintptr(length))
+func GoBytes(ptr unsafe.Pointer, length C.int) []byte {
+	return C.__GoBytes(ptr, uintptr(length))
 }
 
-//go:linkname _Cgo___CBytes runtime.cgo_CBytes
-func _Cgo___CBytes([]byte) unsafe.Pointer
+//go:linkname C.__CBytes runtime.cgo_CBytes
+func __CBytes([]byte) unsafe.Pointer
 
-func _Cgo_CBytes(b []byte) unsafe.Pointer {
-	return _Cgo___CBytes(b)
+func CBytes(b []byte) unsafe.Pointer {
+	return C.__CBytes(b)
 }
 
-//go:linkname _Cgo___get_errno_num runtime.cgo_errno
-func _Cgo___get_errno_num() uintptr
+//go:linkname C.__get_errno_num runtime.cgo_errno
+func __get_errno_num() uintptr
 `
 
 const generatedGoFilePrefixOther = generatedGoFilePrefixBase + `
-func _Cgo___get_errno() error {
-	return syscall.Errno(_Cgo___get_errno_num())
+func __get_errno() error {
+	return syscall.Errno(C.__get_errno_num())
 }
 `
 
@@ -191,7 +197,7 @@ func _Cgo___get_errno() error {
 // map the errno values to match the values in the syscall package.
 // Source of the errno values: lib/mingw-w64/mingw-w64-headers/crt/errno.h
 const generatedGoFilePrefixWindows = generatedGoFilePrefixBase + `
-var _Cgo___errno_mapping = [...]syscall.Errno{
+var __errno_mapping = [...]syscall.Errno{
 	1:  syscall.EPERM,
 	2:  syscall.ENOENT,
 	3:  syscall.ESRCH,
@@ -232,10 +238,10 @@ var _Cgo___errno_mapping = [...]syscall.Errno{
 	42: syscall.EILSEQ,
 }
 
-func _Cgo___get_errno() error {
-	num := _Cgo___get_errno_num()
-	if num < uintptr(len(_Cgo___errno_mapping)) {
-		if mapped := _Cgo___errno_mapping[num]; mapped != 0 {
+func __get_errno() error {
+	num := C.__get_errno_num()
+	if num < uintptr(len(__errno_mapping)) {
+		if mapped := __errno_mapping[num]; mapped != 0 {
 			return mapped
 		}
 	}
@@ -259,7 +265,7 @@ func Process(files []*ast.File, dir, importPath string, fset *token.FileSet, cfl
 		tokenFiles:      map[string]*token.File{},
 		definedGlobally: map[string]ast.Node{},
 		noescapingFuncs: map[string]*noescapingFunc{},
-		anonDecls:       map[any]string{},
+		anonDecls:       map[interface{}]string{},
 		visitedFiles:    map[string][]byte{},
 	}
 
@@ -298,11 +304,28 @@ func Process(files []*ast.File, dir, importPath string, fset *token.FileSet, cfl
 	// If the Comments field is not set to nil, the go/format package will get
 	// confused about where comments should go.
 	p.generated.Comments = nil
+	// Adjust some of the functions in there.
+	for _, decl := range p.generated.Decls {
+		switch decl := decl.(type) {
+		case *ast.FuncDecl:
+			switch decl.Name.Name {
+			case "CString", "GoString", "GoStringN", "__GoStringN", "GoBytes", "__GoBytes", "CBytes", "__CBytes", "__get_errno_num", "__get_errno", "__errno_mapping":
+				// Adjust the name to have a "C." prefix so it is correctly
+				// resolved.
+				decl.Name.Name = "C." + decl.Name.Name
+			}
+		}
+	}
+	// Patch some types, for example *C.char in C.CString.
+	cf := p.newCGoFile(nil, -1) // dummy *cgoFile for the walker
+	astutil.Apply(p.generated, func(cursor *astutil.Cursor) bool {
+		return cf.walker(cursor, nil)
+	}, nil)
 
 	// Find `import "C"` C fragments in the file.
 	p.cgoHeaders = make([]string, len(files)) // combined CGo header fragment for each file
 	for i, f := range files {
-		var cgoHeader strings.Builder
+		var cgoHeader string
 		for i := 0; i < len(f.Decls); i++ {
 			decl := f.Decls[i]
 			genDecl, ok := decl.(*ast.GenDecl)
@@ -337,8 +360,7 @@ func Process(files []*ast.File, dir, importPath string, fset *token.FileSet, cfl
 			// Iterate through all parts of the CGo header. Note that every //
 			// line is a new comment.
 			position := fset.Position(genDecl.Doc.Pos())
-			var fragment strings.Builder
-			fragment.WriteString(fmt.Sprintf("# %d %#v\n", position.Line, position.Filename))
+			fragment := fmt.Sprintf("# %d %#v\n", position.Line, position.Filename)
 			for _, comment := range genDecl.Doc.List {
 				// Find all #cgo lines, extract and use their contents, and
 				// replace the lines with spaces (to preserve locations).
@@ -355,13 +377,12 @@ func Process(files []*ast.File, dir, importPath string, fset *token.FileSet, cfl
 				} else { // comment
 					c = "  " + c[2:len(c)-2]
 				}
-				fragment.WriteString(c)
-				fragment.WriteByte('\n')
+				fragment += c + "\n"
 			}
-			cgoHeader.WriteString(fragment.String())
+			cgoHeader += fragment
 		}
 
-		p.cgoHeaders[i] = cgoHeader.String()
+		p.cgoHeaders[i] = cgoHeader
 	}
 
 	// Define CFlags that will be used while parsing the package.
@@ -378,7 +399,7 @@ func Process(files []*ast.File, dir, importPath string, fset *token.FileSet, cfl
 			Tok:    token.TYPE,
 		}
 		for _, name := range builtinAliases {
-			typeSpec := p.getIntegerType("_Cgo_"+name, names["_Cgo_"+name])
+			typeSpec := p.getIntegerType("C."+name, names["_Cgo_"+name])
 			gen.Specs = append(gen.Specs, typeSpec)
 		}
 		p.generated.Decls = append(p.generated.Decls, gen)
@@ -652,6 +673,7 @@ func (p *cgoPackage) createUnionAccessor(field *ast.Field, typeName string) {
 		X: &ast.Ident{
 			NamePos: pos,
 			Name:    "union",
+			Obj:     nil,
 		},
 		Sel: &ast.Ident{
 			NamePos: pos,
@@ -705,6 +727,7 @@ func (p *cgoPackage) createUnionAccessor(field *ast.Field, typeName string) {
 						X: &ast.Ident{
 							NamePos: pos,
 							Name:    typeName,
+							Obj:     nil,
 						},
 					},
 				},
@@ -760,6 +783,7 @@ func (p *cgoPackage) createBitfieldGetter(bitfield bitfieldInfo, typeName string
 		X: &ast.Ident{
 			NamePos: bitfield.pos,
 			Name:    "s",
+			Obj:     nil,
 		},
 		Sel: &ast.Ident{
 			NamePos: bitfield.pos,
@@ -806,6 +830,11 @@ func (p *cgoPackage) createBitfieldGetter(bitfield bitfieldInfo, typeName string
 						{
 							NamePos: bitfield.pos,
 							Name:    "s",
+							Obj: &ast.Object{
+								Kind: ast.Var,
+								Name: "s",
+								Decl: nil,
+							},
 						},
 					},
 					Type: &ast.StarExpr{
@@ -813,6 +842,7 @@ func (p *cgoPackage) createBitfieldGetter(bitfield bitfieldInfo, typeName string
 						X: &ast.Ident{
 							NamePos: bitfield.pos,
 							Name:    typeName,
+							Obj:     nil,
 						},
 					},
 				},
@@ -870,6 +900,7 @@ func (p *cgoPackage) createBitfieldSetter(bitfield bitfieldInfo, typeName string
 		X: &ast.Ident{
 			NamePos: bitfield.pos,
 			Name:    "s",
+			Obj:     nil,
 		},
 		Sel: &ast.Ident{
 			NamePos: bitfield.pos,
@@ -952,6 +983,11 @@ func (p *cgoPackage) createBitfieldSetter(bitfield bitfieldInfo, typeName string
 						{
 							NamePos: bitfield.pos,
 							Name:    "s",
+							Obj: &ast.Object{
+								Kind: ast.Var,
+								Name: "s",
+								Decl: nil,
+							},
 						},
 					},
 					Type: &ast.StarExpr{
@@ -959,6 +995,7 @@ func (p *cgoPackage) createBitfieldSetter(bitfield bitfieldInfo, typeName string
 						X: &ast.Ident{
 							NamePos: bitfield.pos,
 							Name:    typeName,
+							Obj:     nil,
 						},
 					},
 				},
@@ -979,6 +1016,7 @@ func (p *cgoPackage) createBitfieldSetter(bitfield bitfieldInfo, typeName string
 							{
 								NamePos: bitfield.pos,
 								Name:    "value",
+								Obj:     nil,
 							},
 						},
 						Type: bitfield.field.Type,
@@ -996,6 +1034,7 @@ func (p *cgoPackage) createBitfieldSetter(bitfield bitfieldInfo, typeName string
 							X: &ast.Ident{
 								NamePos: bitfield.pos,
 								Name:    "s",
+								Obj:     nil,
 							},
 							Sel: &ast.Ident{
 								NamePos: bitfield.pos,
@@ -1219,7 +1258,7 @@ func getPos(node ast.Node) token.Pos {
 // getUnnamedDeclName creates a name (with the given prefix) for the given C
 // declaration. This is used for structs, unions, and enums that are often
 // defined without a name and used in a typedef.
-func (p *cgoPackage) getUnnamedDeclName(prefix string, itf any) string {
+func (p *cgoPackage) getUnnamedDeclName(prefix string, itf interface{}) string {
 	if name, ok := p.anonDecls[itf]; ok {
 		return name
 	}
@@ -1233,7 +1272,7 @@ func (p *cgoPackage) getUnnamedDeclName(prefix string, itf any) string {
 func (f *cgoFile) getASTDeclName(name string, found clangCursor, iscall bool) string {
 	// Some types are defined in stdint.h and map directly to a particular Go
 	// type.
-	if alias := cgoAliases["_Cgo_"+name]; alias != "" {
+	if alias := cgoAliases["C."+name]; alias != "" {
 		return alias
 	}
 	node := f.getASTDeclNode(name, found)
@@ -1243,7 +1282,7 @@ func (f *cgoFile) getASTDeclName(name string, found clangCursor, iscall bool) st
 		}
 		return node.Name.Name
 	}
-	return "_Cgo_" + name
+	return "C." + name
 }
 
 // getASTDeclNode will declare the given C AST node (if not already defined) and
@@ -1343,8 +1382,8 @@ extern __typeof(%s) %s __attribute__((alias(%#v)));
 	case *elaboratedTypeInfo:
 		// Add struct bitfields.
 		for _, bitfield := range elaboratedType.bitfields {
-			f.createBitfieldGetter(bitfield, "_Cgo_"+name)
-			f.createBitfieldSetter(bitfield, "_Cgo_"+name)
+			f.createBitfieldGetter(bitfield, "C."+name)
+			f.createBitfieldSetter(bitfield, "C."+name)
 		}
 		if elaboratedType.unionSize != 0 {
 			// Create union getters/setters.
@@ -1353,7 +1392,7 @@ extern __typeof(%s) %s __attribute__((alias(%#v)));
 					f.addError(elaboratedType.pos, fmt.Sprintf("union must have field with a single name, it has %d names", len(field.Names)))
 					continue
 				}
-				f.createUnionAccessor(field, "_Cgo_"+name)
+				f.createUnionAccessor(field, "C."+name)
 			}
 		}
 	}
@@ -1402,7 +1441,7 @@ func (f *cgoFile) walker(cursor *astutil.Cursor, names map[string]clangCursor) b
 			node.Rhs = append(node.Rhs, &ast.CallExpr{
 				Fun: &ast.Ident{
 					NamePos: node.Lhs[1].End(),
-					Name:    "_Cgo___get_errno",
+					Name:    "C.__get_errno",
 				},
 			})
 		}
@@ -1427,7 +1466,7 @@ func (f *cgoFile) walker(cursor *astutil.Cursor, names map[string]clangCursor) b
 			return true
 		}
 		if x.Name == "C" {
-			name := "_Cgo_" + node.Sel.Name
+			name := "C." + node.Sel.Name
 			if found, ok := names[node.Sel.Name]; ok {
 				name = f.getASTDeclName(node.Sel.Name, found, false)
 			}

cgo/cgo_go122.go

@@ -0,0 +1,17 @@
+//go:build go1.22
+
+package cgo
+
+// Code specifically for Go 1.22.
+
+import (
+	"go/ast"
+	"go/token"
+)
+
+func init() {
+	setASTFileFields = func(f *ast.File, start, end token.Pos) {
+		f.FileStart = start
+		f.FileEnd = end
+	}
+}

cgo/cgo_test.go

@@ -45,6 +45,7 @@ func TestCGo(t *testing.T) {
 		"flags",
 		"const",
 	} {
+		name := name // avoid a race condition
 		t.Run(name, func(t *testing.T) {
 			// Read the AST in memory.
 			path := filepath.Join("testdata", name+".go")

cgo/libclang.go

@@ -71,7 +71,7 @@ unsigned tinygo_clang_Cursor_isMacroFunctionLike(GoCXCursor c);
 //     libclang.go:68:5: note: previous declaration is here
 // See: https://github.com/golang/go/issues/49721
 #if defined(_WIN32)
-#define CGO_DECL __declspec(dllexport)
+#define CGO_DECL // __declspec(dllexport)
 #else
 #define CGO_DECL
 #endif
@@ -130,7 +130,7 @@ func (f *cgoFile) readNames(fragment string, cflags []string, filename string, c
 	// convert Go slice of strings to C array of strings.
 	cmdargsC := C.malloc(C.size_t(len(cflags)) * C.size_t(unsafe.Sizeof(uintptr(0))))
 	defer C.free(cmdargsC)
-	cmdargs := unsafe.Slice((**C.char)(cmdargsC), len(cflags))
+	cmdargs := (*[1 << 16]*C.char)(cmdargsC)
 	for i, cflag := range cflags {
 		s := C.CString(cflag)
 		cmdargs[i] = s
@@ -160,7 +160,7 @@ func (f *cgoFile) readNames(fragment string, cflags []string, filename string, c
 			pos := f.getClangLocationPosition(location, unit)
 			f.addError(pos, severity+": "+spelling)
 		}
-		for i := range numDiagnostics {
+		for i := 0; i < numDiagnostics; i++ {
 			diagnostic := C.clang_getDiagnostic(unit, C.uint(i))
 			addDiagnostic(diagnostic)
 
@@ -190,7 +190,7 @@ func (f *cgoFile) readNames(fragment string, cflags []string, filename string, c
 			// Sanity check. This should (hopefully) never trigger.
 			panic("libclang: file contents was not loaded")
 		}
-		data := unsafe.Slice((*byte)(unsafe.Pointer(rawData)), size)
+		data := (*[1 << 24]byte)(unsafe.Pointer(rawData))[:size]
 
 		// Hash the contents if it isn't hashed yet.
 		if _, ok := f.visitedFiles[path]; !ok {
@@ -217,6 +217,10 @@ func (f *cgoFile) createASTNode(name string, c clangCursor) (ast.Node, any) {
 	case C.CXCursor_FunctionDecl:
 		cursorType := C.tinygo_clang_getCursorType(c)
 		numArgs := int(C.tinygo_clang_Cursor_getNumArguments(c))
+		obj := &ast.Object{
+			Kind: ast.Fun,
+			Name: "C." + name,
+		}
 		exportName := name
 		localName := name
 		var stringSignature string
@@ -253,7 +257,8 @@ func (f *cgoFile) createASTNode(name string, c clangCursor) (ast.Node, any) {
 			},
 			Name: &ast.Ident{
 				NamePos: pos,
-				Name:    "_Cgo_" + localName,
+				Name:    "C." + localName,
+				Obj:     obj,
 			},
 			Type: &ast.FuncType{
 				Func: pos,
@@ -278,7 +283,7 @@ func (f *cgoFile) createASTNode(name string, c clangCursor) (ast.Node, any) {
 				Text:  strings.Join(doc, "\n"),
 			})
 		}
-		for i := range numArgs {
+		for i := 0; i < numArgs; i++ {
 			arg := C.tinygo_clang_Cursor_getArgument(c, C.uint(i))
 			argName := getString(C.tinygo_clang_getCursorSpelling(arg))
 			argType := C.clang_getArgType(cursorType, C.uint(i))
@@ -290,6 +295,11 @@ func (f *cgoFile) createASTNode(name string, c clangCursor) (ast.Node, any) {
 					{
 						NamePos: pos,
 						Name:    argName,
+						Obj: &ast.Object{
+							Kind: ast.Var,
+							Name: argName,
+							Decl: decl,
+						},
 					},
 				},
 				Type: f.makeDecayingASTType(argType, pos),
@@ -305,34 +315,49 @@ func (f *cgoFile) createASTNode(name string, c clangCursor) (ast.Node, any) {
 				},
 			}
 		}
+		obj.Decl = decl
 		return decl, stringSignature
 	case C.CXCursor_StructDecl, C.CXCursor_UnionDecl:
 		typ := f.makeASTRecordType(c, pos)
-		typeName := "_Cgo_" + name
+		typeName := "C." + name
 		typeExpr := typ.typeExpr
 		if typ.unionSize != 0 {
 			// Convert to a single-field struct type.
 			typeExpr = f.makeUnionField(typ)
 		}
+		obj := &ast.Object{
+			Kind: ast.Typ,
+			Name: typeName,
+		}
 		typeSpec := &ast.TypeSpec{
 			Name: &ast.Ident{
 				NamePos: typ.pos,
 				Name:    typeName,
+				Obj:     obj,
 			},
 			Type: typeExpr,
 		}
+		obj.Decl = typeSpec
 		return typeSpec, typ
 	case C.CXCursor_TypedefDecl:
-		typeName := "_Cgo_" + name
+		typeName := "C." + name
 		underlyingType := C.tinygo_clang_getTypedefDeclUnderlyingType(c)
+		obj := &ast.Object{
+			Kind: ast.Typ,
+			Name: typeName,
+		}
 		typeSpec := &ast.TypeSpec{
 			Name: &ast.Ident{
 				NamePos: pos,
 				Name:    typeName,
+				Obj:     obj,
 			},
-			Assign: pos,
-			Type:   f.makeASTType(underlyingType, pos),
+			Type: f.makeASTType(underlyingType, pos),
 		}
+		if underlyingType.kind != C.CXType_Enum {
+			typeSpec.Assign = pos
+		}
+		obj.Decl = typeSpec
 		return typeSpec, nil
 	case C.CXCursor_VarDecl:
 		cursorType := C.tinygo_clang_getCursorType(c)
@@ -351,13 +376,19 @@ func (f *cgoFile) createASTNode(name string, c clangCursor) (ast.Node, any) {
 				},
 			},
 		}
+		obj := &ast.Object{
+			Kind: ast.Var,
+			Name: "C." + name,
+		}
 		valueSpec := &ast.ValueSpec{
 			Names: []*ast.Ident{{
 				NamePos: pos,
-				Name:    "_Cgo_" + name,
+				Name:    "C." + name,
+				Obj:     obj,
 			}},
 			Type: typeExpr,
 		}
+		obj.Decl = valueSpec
 		gen.Specs = append(gen.Specs, valueSpec)
 		return gen, nil
 	case C.CXCursor_MacroDefinition:
@@ -374,27 +405,39 @@ func (f *cgoFile) createASTNode(name string, c clangCursor) (ast.Node, any) {
 			Lparen: token.NoPos,
 			Rparen: token.NoPos,
 		}
+		obj := &ast.Object{
+			Kind: ast.Con,
+			Name: "C." + name,
+		}
 		valueSpec := &ast.ValueSpec{
 			Names: []*ast.Ident{{
 				NamePos: pos,
-				Name:    "_Cgo_" + name,
+				Name:    "C." + name,
+				Obj:     obj,
 			}},
 			Values: []ast.Expr{expr},
 		}
+		obj.Decl = valueSpec
 		gen.Specs = append(gen.Specs, valueSpec)
 		return gen, nil
 	case C.CXCursor_EnumDecl:
+		obj := &ast.Object{
+			Kind: ast.Typ,
+			Name: "C." + name,
+		}
 		underlying := C.tinygo_clang_getEnumDeclIntegerType(c)
 		// TODO: gc's CGo implementation uses types such as `uint32` for enums
 		// instead of types such as C.int, which are used here.
 		typeSpec := &ast.TypeSpec{
 			Name: &ast.Ident{
 				NamePos: pos,
-				Name:    "_Cgo_" + name,
+				Name:    "C." + name,
+				Obj:     obj,
 			},
 			Assign: pos,
 			Type:   f.makeASTType(underlying, pos),
 		}
+		obj.Decl = typeSpec
 		return typeSpec, nil
 	case C.CXCursor_EnumConstantDecl:
 		value := C.tinygo_clang_getEnumConstantDeclValue(c)
@@ -409,13 +452,19 @@ func (f *cgoFile) createASTNode(name string, c clangCursor) (ast.Node, any) {
 			Lparen: token.NoPos,
 			Rparen: token.NoPos,
 		}
+		obj := &ast.Object{
+			Kind: ast.Con,
+			Name: "C." + name,
+		}
 		valueSpec := &ast.ValueSpec{
 			Names: []*ast.Ident{{
 				NamePos: pos,
-				Name:    "_Cgo_" + name,
+				Name:    "C." + name,
+				Obj:     obj,
 			}},
 			Values: []ast.Expr{expr},
 		}
+		obj.Decl = valueSpec
 		gen.Specs = append(gen.Specs, valueSpec)
 		return gen, nil
 	default:
@@ -532,7 +581,7 @@ func tinygo_clang_globals_visitor(c, parent C.GoCXCursor, client_data C.CXClient
 
 // Get the precise location in the source code. Used for uniquely identifying
 // source locations.
-func (f *cgoFile) getUniqueLocationID(pos token.Pos, cursor C.GoCXCursor) any {
+func (f *cgoFile) getUniqueLocationID(pos token.Pos, cursor C.GoCXCursor) interface{} {
 	clangLocation := C.tinygo_clang_getCursorLocation(cursor)
 	var file C.CXFile
 	var line C.unsigned
@@ -575,7 +624,7 @@ func (p *cgoPackage) getClangLocationPosition(location C.CXSourceLocation, tu C.
 		// now by reading the file from libclang.
 		var size C.size_t
 		sourcePtr := C.clang_getFileContents(tu, file, &size)
-		source := unsafe.Slice((*byte)(unsafe.Pointer(sourcePtr)), size)
+		source := ((*[1 << 28]byte)(unsafe.Pointer(sourcePtr)))[:size:size]
 		lines := []int{0}
 		for i := 0; i < len(source)-1; i++ {
 			if source[i] == '\n' {
@@ -590,8 +639,7 @@ func (p *cgoPackage) getClangLocationPosition(location C.CXSourceLocation, tu C.
 			Package: f.Pos(0),
 			Name:    ast.NewIdent(p.packageName),
 		}
-		astFile.FileStart = f.Pos(0)
-		astFile.FileEnd = f.Pos(int(size))
+		setASTFileFields(astFile, f.Pos(0), f.Pos(int(size)))
 		p.cgoFiles = append(p.cgoFiles, astFile)
 	}
 	positionFile := p.tokenFiles[filename]
@@ -697,27 +745,27 @@ func (f *cgoFile) makeASTType(typ C.CXType, pos token.Pos) ast.Expr {
 	var typeName string
 	switch typ.kind {
 	case C.CXType_Char_S, C.CXType_Char_U:
-		typeName = "_Cgo_char"
+		typeName = "C.char"
 	case C.CXType_SChar:
-		typeName = "_Cgo_schar"
+		typeName = "C.schar"
 	case C.CXType_UChar:
-		typeName = "_Cgo_uchar"
+		typeName = "C.uchar"
 	case C.CXType_Short:
-		typeName = "_Cgo_short"
+		typeName = "C.short"
 	case C.CXType_UShort:
-		typeName = "_Cgo_ushort"
+		typeName = "C.ushort"
 	case C.CXType_Int:
-		typeName = "_Cgo_int"
+		typeName = "C.int"
 	case C.CXType_UInt:
-		typeName = "_Cgo_uint"
+		typeName = "C.uint"
 	case C.CXType_Long:
-		typeName = "_Cgo_long"
+		typeName = "C.long"
 	case C.CXType_ULong:
-		typeName = "_Cgo_ulong"
+		typeName = "C.ulong"
 	case C.CXType_LongLong:
-		typeName = "_Cgo_longlong"
+		typeName = "C.longlong"
 	case C.CXType_ULongLong:
-		typeName = "_Cgo_ulonglong"
+		typeName = "C.ulonglong"
 	case C.CXType_Bool:
 		typeName = "bool"
 	case C.CXType_Float, C.CXType_Double, C.CXType_LongDouble:
@@ -804,14 +852,6 @@ func (f *cgoFile) makeASTType(typ C.CXType, pos token.Pos) ast.Expr {
 			f.addError(pos, fmt.Sprintf("unknown elaborated type (libclang type kind %s)", typeKindSpelling))
 			typeName = "<unknown>"
 		}
-	case C.CXType_Unexposed:
-		// LLVM 22+ may report certain builtin type aliases (e.g. __size_t)
-		// as Unexposed. Resolve via the canonical type.
-		canonical := C.clang_getCanonicalType(typ)
-		if canonical.kind != C.CXType_Unexposed && canonical.kind != C.CXType_Invalid {
-			return f.makeASTType(canonical, pos)
-		}
-		// If still unexposed, fall through to the error below.
 	case C.CXType_Record:
 		cursor := C.tinygo_clang_getTypeDeclaration(typ)
 		name := getString(C.tinygo_clang_getCursorSpelling(cursor))
@@ -856,7 +896,7 @@ func (f *cgoFile) makeASTType(typ C.CXType, pos token.Pos) ast.Expr {
 		typeSpelling := getString(C.clang_getTypeSpelling(typ))
 		typeKindSpelling := getString(C.clang_getTypeKindSpelling(typ.kind))
 		f.addError(pos, fmt.Sprintf("unknown C type: %v (libclang type kind %s)", typeSpelling, typeKindSpelling))
-		typeName = "_Cgo_<unknown>"
+		typeName = "C.<unknown>"
 	}
 	return &ast.Ident{
 		NamePos: pos,
@@ -873,7 +913,7 @@ func (p *cgoPackage) getIntegerType(name string, cursor clangCursor) *ast.TypeSp
 	var goName string
 	typeSize := C.clang_Type_getSizeOf(underlyingType)
 	switch name {
-	case "_Cgo_char":
+	case "C.char":
 		if typeSize != 1 {
 			// This happens for some very special purpose architectures
 			// (DSPs etc.) that are not currently targeted.
@@ -886,7 +926,7 @@ func (p *cgoPackage) getIntegerType(name string, cursor clangCursor) *ast.TypeSp
 		case C.CXType_Char_U:
 			goName = "uint8"
 		}
-	case "_Cgo_schar", "_Cgo_short", "_Cgo_int", "_Cgo_long", "_Cgo_longlong":
+	case "C.schar", "C.short", "C.int", "C.long", "C.longlong":
 		switch typeSize {
 		case 1:
 			goName = "int8"
@@ -897,7 +937,7 @@ func (p *cgoPackage) getIntegerType(name string, cursor clangCursor) *ast.TypeSp
 		case 8:
 			goName = "int64"
 		}
-	case "_Cgo_uchar", "_Cgo_ushort", "_Cgo_uint", "_Cgo_ulong", "_Cgo_ulonglong":
+	case "C.uchar", "C.ushort", "C.uint", "C.ulong", "C.ulonglong":
 		switch typeSize {
 		case 1:
 			goName = "uint8"
@@ -916,16 +956,22 @@ func (p *cgoPackage) getIntegerType(name string, cursor clangCursor) *ast.TypeSp
 	}
 
 	// Construct an *ast.TypeSpec for this type.
+	obj := &ast.Object{
+		Kind: ast.Typ,
+		Name: name,
+	}
 	spec := &ast.TypeSpec{
 		Name: &ast.Ident{
 			NamePos: pos,
 			Name:    name,
+			Obj:     obj,
 		},
 		Type: &ast.Ident{
 			NamePos: pos,
 			Name:    goName,
 		},
 	}
+	obj.Decl = spec
 	return spec
 }
 
@@ -1058,6 +1104,7 @@ func tinygo_clang_struct_visitor(c, parent C.GoCXCursor, client_data C.CXClientD
 				pos:      prevField.Names[0].NamePos,
 			})
 			prevField.Names[0].Name = bitfieldName
+			prevField.Names[0].Obj.Name = bitfieldName
 		}
 		prevBitfield := &(*bitfieldList)[len(*bitfieldList)-1]
 		prevBitfield.endBit = bitfieldOffset
@@ -1074,6 +1121,11 @@ func tinygo_clang_struct_visitor(c, parent C.GoCXCursor, client_data C.CXClientD
 		{
 			NamePos: pos,
 			Name:    name,
+			Obj: &ast.Object{
+				Kind: ast.Var,
+				Name: name,
+				Decl: field,
+			},
 		},
 	}
 	fieldList.List = append(fieldList.List, field)

cgo/libclang_config_llvm19.go

@@ -1,9 +1,9 @@
-//go:build !byollvm && llvm19
+//go:build !byollvm && !llvm15 && !llvm16 && !llvm17 && !llvm18
 
 package cgo
 
 /*
-#cgo linux        CFLAGS:  -I/usr/include/llvm-19 -I/usr/include/llvm-c-19 -I/usr/lib/llvm-19/include -I/usr/lib64/llvm19/include
+#cgo linux        CFLAGS:  -I/usr/include/llvm-19 -I/usr/include/llvm-c-19 -I/usr/lib/llvm-19/include
 #cgo darwin,amd64 CFLAGS:  -I/usr/local/opt/llvm@19/include
 #cgo darwin,arm64 CFLAGS:  -I/opt/homebrew/opt/llvm@19/include
 #cgo freebsd      CFLAGS:  -I/usr/local/llvm19/include

cgo/libclang_config_llvm20.go

@@ -1,15 +0,0 @@
-//go:build !byollvm && !llvm15 && !llvm16 && !llvm17 && !llvm18 && !llvm19 && !llvm21 && !llvm22
-
-package cgo
-
-/*
-#cgo linux        CFLAGS:  -I/usr/include/llvm-20 -I/usr/include/llvm-c-20 -I/usr/lib/llvm-20/include -I/usr/lib64/llvm20/include
-#cgo darwin,amd64 CFLAGS:  -I/usr/local/opt/llvm@20/include
-#cgo darwin,arm64 CFLAGS:  -I/opt/homebrew/opt/llvm@20/include
-#cgo freebsd      CFLAGS:  -I/usr/local/llvm20/include
-#cgo linux        LDFLAGS: -L/usr/lib/llvm-20/lib -lclang
-#cgo darwin,amd64 LDFLAGS: -L/usr/local/opt/llvm@20/lib -lclang
-#cgo darwin,arm64 LDFLAGS: -L/opt/homebrew/opt/llvm@20/lib -lclang
-#cgo freebsd      LDFLAGS: -L/usr/local/llvm20/lib -lclang
-*/
-import "C"

cgo/libclang_config_llvm21.go

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

cgo/libclang_config_llvm22.go

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

cgo/security.go

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

cgo/sync.go

@@ -12,17 +12,17 @@ import "C"
 // C. It is useful if an API uses function pointers and you cannot pass a Go
 // pointer but only a C pointer.
 type refMap struct {
-	refs map[unsafe.Pointer]any
+	refs map[unsafe.Pointer]interface{}
 	lock sync.Mutex
 }
 
 // Put stores a value in the map. It can later be retrieved using Get. It must
 // be removed using Remove to avoid memory leaks.
-func (m *refMap) Put(v any) unsafe.Pointer {
+func (m *refMap) Put(v interface{}) unsafe.Pointer {
 	m.lock.Lock()
 	defer m.lock.Unlock()
 	if m.refs == nil {
-		m.refs = make(map[unsafe.Pointer]any, 1)
+		m.refs = make(map[unsafe.Pointer]interface{}, 1)
 	}
 	ref := C.malloc(1)
 	m.refs[ref] = v
@@ -31,7 +31,7 @@ func (m *refMap) Put(v any) unsafe.Pointer {
 
 // Get returns a stored value previously inserted with Put. Use the same
 // reference as you got from Put.
-func (m *refMap) Get(ref unsafe.Pointer) any {
+func (m *refMap) Get(ref unsafe.Pointer) interface{} {
 	m.lock.Lock()
 	defer m.lock.Unlock()
 	return m.refs[ref]

cgo/testdata/basic.out.go

@@ -5,50 +5,50 @@ import "unsafe"
 
 var _ unsafe.Pointer
 
-//go:linkname _Cgo_CString runtime.cgo_CString
-func _Cgo_CString(string) *_Cgo_char
+//go:linkname C.CString runtime.cgo_CString
+func C.CString(string) *C.char
 
-//go:linkname _Cgo_GoString runtime.cgo_GoString
-func _Cgo_GoString(*_Cgo_char) string
+//go:linkname C.GoString runtime.cgo_GoString
+func C.GoString(*C.char) string
 
-//go:linkname _Cgo___GoStringN runtime.cgo_GoStringN
-func _Cgo___GoStringN(*_Cgo_char, uintptr) string
+//go:linkname C.__GoStringN runtime.cgo_GoStringN
+func C.__GoStringN(*C.char, uintptr) string
 
-func _Cgo_GoStringN(cstr *_Cgo_char, length _Cgo_int) string {
-	return _Cgo___GoStringN(cstr, uintptr(length))
+func C.GoStringN(cstr *C.char, length C.int) string {
+	return C.__GoStringN(cstr, uintptr(length))
 }
 
-//go:linkname _Cgo___GoBytes runtime.cgo_GoBytes
-func _Cgo___GoBytes(unsafe.Pointer, uintptr) []byte
+//go:linkname C.__GoBytes runtime.cgo_GoBytes
+func C.__GoBytes(unsafe.Pointer, uintptr) []byte
 
-func _Cgo_GoBytes(ptr unsafe.Pointer, length _Cgo_int) []byte {
-	return _Cgo___GoBytes(ptr, uintptr(length))
+func C.GoBytes(ptr unsafe.Pointer, length C.int) []byte {
+	return C.__GoBytes(ptr, uintptr(length))
 }
 
-//go:linkname _Cgo___CBytes runtime.cgo_CBytes
-func _Cgo___CBytes([]byte) unsafe.Pointer
+//go:linkname C.__CBytes runtime.cgo_CBytes
+func C.__CBytes([]byte) unsafe.Pointer
 
-func _Cgo_CBytes(b []byte) unsafe.Pointer {
-	return _Cgo___CBytes(b)
+func C.CBytes(b []byte) unsafe.Pointer {
+	return C.__CBytes(b)
 }
 
-//go:linkname _Cgo___get_errno_num runtime.cgo_errno
-func _Cgo___get_errno_num() uintptr
+//go:linkname C.__get_errno_num runtime.cgo_errno
+func C.__get_errno_num() uintptr
 
-func _Cgo___get_errno() error {
-	return syscall.Errno(_Cgo___get_errno_num())
+func C.__get_errno() error {
+	return syscall.Errno(C.__get_errno_num())
 }
 
 type (
-	_Cgo_char      uint8
-	_Cgo_schar     int8
-	_Cgo_uchar     uint8
-	_Cgo_short     int16
-	_Cgo_ushort    uint16
-	_Cgo_int       int32
-	_Cgo_uint      uint32
-	_Cgo_long      int32
-	_Cgo_ulong     uint32
-	_Cgo_longlong  int64
-	_Cgo_ulonglong uint64
+	C.char      uint8
+	C.schar     int8
+	C.uchar     uint8
+	C.short     int16
+	C.ushort    uint16
+	C.int       int32
+	C.uint      uint32
+	C.long      int32
+	C.ulong     uint32
+	C.longlong  int64
+	C.ulonglong uint64
 )

cgo/testdata/const.out.go

@@ -5,58 +5,58 @@ import "unsafe"
 
 var _ unsafe.Pointer
 
-//go:linkname _Cgo_CString runtime.cgo_CString
-func _Cgo_CString(string) *_Cgo_char
+//go:linkname C.CString runtime.cgo_CString
+func C.CString(string) *C.char
 
-//go:linkname _Cgo_GoString runtime.cgo_GoString
-func _Cgo_GoString(*_Cgo_char) string
+//go:linkname C.GoString runtime.cgo_GoString
+func C.GoString(*C.char) string
 
-//go:linkname _Cgo___GoStringN runtime.cgo_GoStringN
-func _Cgo___GoStringN(*_Cgo_char, uintptr) string
+//go:linkname C.__GoStringN runtime.cgo_GoStringN
+func C.__GoStringN(*C.char, uintptr) string
 
-func _Cgo_GoStringN(cstr *_Cgo_char, length _Cgo_int) string {
-	return _Cgo___GoStringN(cstr, uintptr(length))
+func C.GoStringN(cstr *C.char, length C.int) string {
+	return C.__GoStringN(cstr, uintptr(length))
 }
 
-//go:linkname _Cgo___GoBytes runtime.cgo_GoBytes
-func _Cgo___GoBytes(unsafe.Pointer, uintptr) []byte
+//go:linkname C.__GoBytes runtime.cgo_GoBytes
+func C.__GoBytes(unsafe.Pointer, uintptr) []byte
 
-func _Cgo_GoBytes(ptr unsafe.Pointer, length _Cgo_int) []byte {
-	return _Cgo___GoBytes(ptr, uintptr(length))
+func C.GoBytes(ptr unsafe.Pointer, length C.int) []byte {
+	return C.__GoBytes(ptr, uintptr(length))
 }
 
-//go:linkname _Cgo___CBytes runtime.cgo_CBytes
-func _Cgo___CBytes([]byte) unsafe.Pointer
+//go:linkname C.__CBytes runtime.cgo_CBytes
+func C.__CBytes([]byte) unsafe.Pointer
 
-func _Cgo_CBytes(b []byte) unsafe.Pointer {
-	return _Cgo___CBytes(b)
+func C.CBytes(b []byte) unsafe.Pointer {
+	return C.__CBytes(b)
 }
 
-//go:linkname _Cgo___get_errno_num runtime.cgo_errno
-func _Cgo___get_errno_num() uintptr
+//go:linkname C.__get_errno_num runtime.cgo_errno
+func C.__get_errno_num() uintptr
 
-func _Cgo___get_errno() error {
-	return syscall.Errno(_Cgo___get_errno_num())
+func C.__get_errno() error {
+	return syscall.Errno(C.__get_errno_num())
 }
 
 type (
-	_Cgo_char      uint8
-	_Cgo_schar     int8
-	_Cgo_uchar     uint8
-	_Cgo_short     int16
-	_Cgo_ushort    uint16
-	_Cgo_int       int32
-	_Cgo_uint      uint32
-	_Cgo_long      int32
-	_Cgo_ulong     uint32
-	_Cgo_longlong  int64
-	_Cgo_ulonglong uint64
+	C.char      uint8
+	C.schar     int8
+	C.uchar     uint8
+	C.short     int16
+	C.ushort    uint16
+	C.int       int32
+	C.uint      uint32
+	C.long      int32
+	C.ulong     uint32
+	C.longlong  int64
+	C.ulonglong uint64
 )
 
-const _Cgo_foo = 3
-const _Cgo_bar = _Cgo_foo
-const _Cgo_unreferenced = 4
-const _Cgo_referenced = _Cgo_unreferenced
-const _Cgo_fnlike_val = 5
-const _Cgo_square_val = (20 * 20)
-const _Cgo_add_val = (3 + 5)
+const C.foo = 3
+const C.bar = C.foo
+const C.unreferenced = 4
+const C.referenced = C.unreferenced
+const C.fnlike_val = 5
+const C.square_val = (20 * 20)
+const C.add_val = (3 + 5)

cgo/testdata/errors.out.go

@@ -14,16 +14,16 @@
 //     testdata/errors.go:3:1: function "unusedFunction" in #cgo noescape line is not used
 
 // Type checking errors after CGo processing:
-//     testdata/errors.go:102: cannot use 2 << 10 (untyped int constant 2048) as _Cgo_char value in variable declaration (overflows)
+//     testdata/errors.go:102: cannot use 2 << 10 (untyped int constant 2048) as C.char value in variable declaration (overflows)
 //     testdata/errors.go:105: unknown field z in struct literal
-//     testdata/errors.go:108: undefined: _Cgo_SOME_CONST_1
-//     testdata/errors.go:110: cannot use _Cgo_SOME_CONST_3 (untyped int constant 1234) as byte value in variable declaration (overflows)
-//     testdata/errors.go:112: undefined: _Cgo_SOME_CONST_4
-//     testdata/errors.go:114: undefined: _Cgo_SOME_CONST_b
-//     testdata/errors.go:116: undefined: _Cgo_SOME_CONST_startspace
-//     testdata/errors.go:119: undefined: _Cgo_SOME_PARAM_CONST_invalid
-//     testdata/errors.go:122: undefined: _Cgo_add_toomuch
-//     testdata/errors.go:123: undefined: _Cgo_add_toolittle
+//     testdata/errors.go:108: undefined: C.SOME_CONST_1
+//     testdata/errors.go:110: cannot use C.SOME_CONST_3 (untyped int constant 1234) as byte value in variable declaration (overflows)
+//     testdata/errors.go:112: undefined: C.SOME_CONST_4
+//     testdata/errors.go:114: undefined: C.SOME_CONST_b
+//     testdata/errors.go:116: undefined: C.SOME_CONST_startspace
+//     testdata/errors.go:119: undefined: C.SOME_PARAM_CONST_invalid
+//     testdata/errors.go:122: undefined: C.add_toomuch
+//     testdata/errors.go:123: undefined: C.add_toolittle
 
 package main
 
@@ -32,58 +32,58 @@ import "unsafe"
 
 var _ unsafe.Pointer
 
-//go:linkname _Cgo_CString runtime.cgo_CString
-func _Cgo_CString(string) *_Cgo_char
+//go:linkname C.CString runtime.cgo_CString
+func C.CString(string) *C.char
 
-//go:linkname _Cgo_GoString runtime.cgo_GoString
-func _Cgo_GoString(*_Cgo_char) string
+//go:linkname C.GoString runtime.cgo_GoString
+func C.GoString(*C.char) string
 
-//go:linkname _Cgo___GoStringN runtime.cgo_GoStringN
-func _Cgo___GoStringN(*_Cgo_char, uintptr) string
+//go:linkname C.__GoStringN runtime.cgo_GoStringN
+func C.__GoStringN(*C.char, uintptr) string
 
-func _Cgo_GoStringN(cstr *_Cgo_char, length _Cgo_int) string {
-	return _Cgo___GoStringN(cstr, uintptr(length))
+func C.GoStringN(cstr *C.char, length C.int) string {
+	return C.__GoStringN(cstr, uintptr(length))
 }
 
-//go:linkname _Cgo___GoBytes runtime.cgo_GoBytes
-func _Cgo___GoBytes(unsafe.Pointer, uintptr) []byte
+//go:linkname C.__GoBytes runtime.cgo_GoBytes
+func C.__GoBytes(unsafe.Pointer, uintptr) []byte
 
-func _Cgo_GoBytes(ptr unsafe.Pointer, length _Cgo_int) []byte {
-	return _Cgo___GoBytes(ptr, uintptr(length))
+func C.GoBytes(ptr unsafe.Pointer, length C.int) []byte {
+	return C.__GoBytes(ptr, uintptr(length))
 }
 
-//go:linkname _Cgo___CBytes runtime.cgo_CBytes
-func _Cgo___CBytes([]byte) unsafe.Pointer
+//go:linkname C.__CBytes runtime.cgo_CBytes
+func C.__CBytes([]byte) unsafe.Pointer
 
-func _Cgo_CBytes(b []byte) unsafe.Pointer {
-	return _Cgo___CBytes(b)
+func C.CBytes(b []byte) unsafe.Pointer {
+	return C.__CBytes(b)
 }
 
-//go:linkname _Cgo___get_errno_num runtime.cgo_errno
-func _Cgo___get_errno_num() uintptr
+//go:linkname C.__get_errno_num runtime.cgo_errno
+func C.__get_errno_num() uintptr
 
-func _Cgo___get_errno() error {
-	return syscall.Errno(_Cgo___get_errno_num())
+func C.__get_errno() error {
+	return syscall.Errno(C.__get_errno_num())
 }
 
 type (
-	_Cgo_char      uint8
-	_Cgo_schar     int8
-	_Cgo_uchar     uint8
-	_Cgo_short     int16
-	_Cgo_ushort    uint16
-	_Cgo_int       int32
-	_Cgo_uint      uint32
-	_Cgo_long      int32
-	_Cgo_ulong     uint32
-	_Cgo_longlong  int64
-	_Cgo_ulonglong uint64
+	C.char      uint8
+	C.schar     int8
+	C.uchar     uint8
+	C.short     int16
+	C.ushort    uint16
+	C.int       int32
+	C.uint      uint32
+	C.long      int32
+	C.ulong     uint32
+	C.longlong  int64
+	C.ulonglong uint64
 )
-type _Cgo_struct_point_t struct {
-	x _Cgo_int
-	y _Cgo_int
+type C.struct_point_t struct {
+	x C.int
+	y C.int
 }
-type _Cgo_point_t = _Cgo_struct_point_t
+type C.point_t = C.struct_point_t
 
-const _Cgo_SOME_CONST_3 = 1234
-const _Cgo_SOME_PARAM_CONST_valid = 3 + 4
+const C.SOME_CONST_3 = 1234
+const C.SOME_PARAM_CONST_valid = 3 + 4

cgo/testdata/flags.out.go

@@ -10,53 +10,53 @@ import "unsafe"
 
 var _ unsafe.Pointer
 
-//go:linkname _Cgo_CString runtime.cgo_CString
-func _Cgo_CString(string) *_Cgo_char
+//go:linkname C.CString runtime.cgo_CString
+func C.CString(string) *C.char
 
-//go:linkname _Cgo_GoString runtime.cgo_GoString
-func _Cgo_GoString(*_Cgo_char) string
+//go:linkname C.GoString runtime.cgo_GoString
+func C.GoString(*C.char) string
 
-//go:linkname _Cgo___GoStringN runtime.cgo_GoStringN
-func _Cgo___GoStringN(*_Cgo_char, uintptr) string
+//go:linkname C.__GoStringN runtime.cgo_GoStringN
+func C.__GoStringN(*C.char, uintptr) string
 
-func _Cgo_GoStringN(cstr *_Cgo_char, length _Cgo_int) string {
-	return _Cgo___GoStringN(cstr, uintptr(length))
+func C.GoStringN(cstr *C.char, length C.int) string {
+	return C.__GoStringN(cstr, uintptr(length))
 }
 
-//go:linkname _Cgo___GoBytes runtime.cgo_GoBytes
-func _Cgo___GoBytes(unsafe.Pointer, uintptr) []byte
+//go:linkname C.__GoBytes runtime.cgo_GoBytes
+func C.__GoBytes(unsafe.Pointer, uintptr) []byte
 
-func _Cgo_GoBytes(ptr unsafe.Pointer, length _Cgo_int) []byte {
-	return _Cgo___GoBytes(ptr, uintptr(length))
+func C.GoBytes(ptr unsafe.Pointer, length C.int) []byte {
+	return C.__GoBytes(ptr, uintptr(length))
 }
 
-//go:linkname _Cgo___CBytes runtime.cgo_CBytes
-func _Cgo___CBytes([]byte) unsafe.Pointer
+//go:linkname C.__CBytes runtime.cgo_CBytes
+func C.__CBytes([]byte) unsafe.Pointer
 
-func _Cgo_CBytes(b []byte) unsafe.Pointer {
-	return _Cgo___CBytes(b)
+func C.CBytes(b []byte) unsafe.Pointer {
+	return C.__CBytes(b)
 }
 
-//go:linkname _Cgo___get_errno_num runtime.cgo_errno
-func _Cgo___get_errno_num() uintptr
+//go:linkname C.__get_errno_num runtime.cgo_errno
+func C.__get_errno_num() uintptr
 
-func _Cgo___get_errno() error {
-	return syscall.Errno(_Cgo___get_errno_num())
+func C.__get_errno() error {
+	return syscall.Errno(C.__get_errno_num())
 }
 
 type (
-	_Cgo_char      uint8
-	_Cgo_schar     int8
-	_Cgo_uchar     uint8
-	_Cgo_short     int16
-	_Cgo_ushort    uint16
-	_Cgo_int       int32
-	_Cgo_uint      uint32
-	_Cgo_long      int32
-	_Cgo_ulong     uint32
-	_Cgo_longlong  int64
-	_Cgo_ulonglong uint64
+	C.char      uint8
+	C.schar     int8
+	C.uchar     uint8
+	C.short     int16
+	C.ushort    uint16
+	C.int       int32
+	C.uint      uint32
+	C.long      int32
+	C.ulong     uint32
+	C.longlong  int64
+	C.ulonglong uint64
 )
 
-const _Cgo_BAR = 3
-const _Cgo_FOO_H = 1
+const C.BAR = 3
+const C.FOO_H = 1

cgo/testdata/symbols.out.go

@@ -5,80 +5,80 @@ import "unsafe"
 
 var _ unsafe.Pointer
 
-//go:linkname _Cgo_CString runtime.cgo_CString
-func _Cgo_CString(string) *_Cgo_char
+//go:linkname C.CString runtime.cgo_CString
+func C.CString(string) *C.char
 
-//go:linkname _Cgo_GoString runtime.cgo_GoString
-func _Cgo_GoString(*_Cgo_char) string
+//go:linkname C.GoString runtime.cgo_GoString
+func C.GoString(*C.char) string
 
-//go:linkname _Cgo___GoStringN runtime.cgo_GoStringN
-func _Cgo___GoStringN(*_Cgo_char, uintptr) string
+//go:linkname C.__GoStringN runtime.cgo_GoStringN
+func C.__GoStringN(*C.char, uintptr) string
 
-func _Cgo_GoStringN(cstr *_Cgo_char, length _Cgo_int) string {
-	return _Cgo___GoStringN(cstr, uintptr(length))
+func C.GoStringN(cstr *C.char, length C.int) string {
+	return C.__GoStringN(cstr, uintptr(length))
 }
 
-//go:linkname _Cgo___GoBytes runtime.cgo_GoBytes
-func _Cgo___GoBytes(unsafe.Pointer, uintptr) []byte
+//go:linkname C.__GoBytes runtime.cgo_GoBytes
+func C.__GoBytes(unsafe.Pointer, uintptr) []byte
 
-func _Cgo_GoBytes(ptr unsafe.Pointer, length _Cgo_int) []byte {
-	return _Cgo___GoBytes(ptr, uintptr(length))
+func C.GoBytes(ptr unsafe.Pointer, length C.int) []byte {
+	return C.__GoBytes(ptr, uintptr(length))
 }
 
-//go:linkname _Cgo___CBytes runtime.cgo_CBytes
-func _Cgo___CBytes([]byte) unsafe.Pointer
+//go:linkname C.__CBytes runtime.cgo_CBytes
+func C.__CBytes([]byte) unsafe.Pointer
 
-func _Cgo_CBytes(b []byte) unsafe.Pointer {
-	return _Cgo___CBytes(b)
+func C.CBytes(b []byte) unsafe.Pointer {
+	return C.__CBytes(b)
 }
 
-//go:linkname _Cgo___get_errno_num runtime.cgo_errno
-func _Cgo___get_errno_num() uintptr
+//go:linkname C.__get_errno_num runtime.cgo_errno
+func C.__get_errno_num() uintptr
 
-func _Cgo___get_errno() error {
-	return syscall.Errno(_Cgo___get_errno_num())
+func C.__get_errno() error {
+	return syscall.Errno(C.__get_errno_num())
 }
 
 type (
-	_Cgo_char      uint8
-	_Cgo_schar     int8
-	_Cgo_uchar     uint8
-	_Cgo_short     int16
-	_Cgo_ushort    uint16
-	_Cgo_int       int32
-	_Cgo_uint      uint32
-	_Cgo_long      int32
-	_Cgo_ulong     uint32
-	_Cgo_longlong  int64
-	_Cgo_ulonglong uint64
+	C.char      uint8
+	C.schar     int8
+	C.uchar     uint8
+	C.short     int16
+	C.ushort    uint16
+	C.int       int32
+	C.uint      uint32
+	C.long      int32
+	C.ulong     uint32
+	C.longlong  int64
+	C.ulonglong uint64
 )
 
 //export foo
-func _Cgo_foo(a _Cgo_int, b _Cgo_int) _Cgo_int
+func C.foo(a C.int, b C.int) C.int
 
-var _Cgo_foo$funcaddr unsafe.Pointer
+var C.foo$funcaddr unsafe.Pointer
 
 //export variadic0
 //go:variadic
-func _Cgo_variadic0()
+func C.variadic0()
 
-var _Cgo_variadic0$funcaddr unsafe.Pointer
+var C.variadic0$funcaddr unsafe.Pointer
 
 //export variadic2
 //go:variadic
-func _Cgo_variadic2(x _Cgo_int, y _Cgo_int)
+func C.variadic2(x C.int, y C.int)
 
-var _Cgo_variadic2$funcaddr unsafe.Pointer
+var C.variadic2$funcaddr unsafe.Pointer
 
 //export _Cgo_static_173c95a79b6df1980521_staticfunc
-func _Cgo_staticfunc!symbols.go(x _Cgo_int)
+func C.staticfunc!symbols.go(x C.int)
 
-var _Cgo_staticfunc!symbols.go$funcaddr unsafe.Pointer
+var C.staticfunc!symbols.go$funcaddr unsafe.Pointer
 
 //export notEscapingFunction
 //go:noescape
-func _Cgo_notEscapingFunction(a *_Cgo_int)
+func C.notEscapingFunction(a *C.int)
 
-var _Cgo_notEscapingFunction$funcaddr unsafe.Pointer
+var C.notEscapingFunction$funcaddr unsafe.Pointer
 //go:extern someValue
-var _Cgo_someValue _Cgo_int
+var C.someValue C.int

cgo/testdata/types.out.go

@@ -5,162 +5,158 @@ import "unsafe"
 
 var _ unsafe.Pointer
 
-//go:linkname _Cgo_CString runtime.cgo_CString
-func _Cgo_CString(string) *_Cgo_char
+//go:linkname C.CString runtime.cgo_CString
+func C.CString(string) *C.char
 
-//go:linkname _Cgo_GoString runtime.cgo_GoString
-func _Cgo_GoString(*_Cgo_char) string
+//go:linkname C.GoString runtime.cgo_GoString
+func C.GoString(*C.char) string
 
-//go:linkname _Cgo___GoStringN runtime.cgo_GoStringN
-func _Cgo___GoStringN(*_Cgo_char, uintptr) string
+//go:linkname C.__GoStringN runtime.cgo_GoStringN
+func C.__GoStringN(*C.char, uintptr) string
 
-func _Cgo_GoStringN(cstr *_Cgo_char, length _Cgo_int) string {
-	return _Cgo___GoStringN(cstr, uintptr(length))
+func C.GoStringN(cstr *C.char, length C.int) string {
+	return C.__GoStringN(cstr, uintptr(length))
 }
 
-//go:linkname _Cgo___GoBytes runtime.cgo_GoBytes
-func _Cgo___GoBytes(unsafe.Pointer, uintptr) []byte
+//go:linkname C.__GoBytes runtime.cgo_GoBytes
+func C.__GoBytes(unsafe.Pointer, uintptr) []byte
 
-func _Cgo_GoBytes(ptr unsafe.Pointer, length _Cgo_int) []byte {
-	return _Cgo___GoBytes(ptr, uintptr(length))
+func C.GoBytes(ptr unsafe.Pointer, length C.int) []byte {
+	return C.__GoBytes(ptr, uintptr(length))
 }
 
-//go:linkname _Cgo___CBytes runtime.cgo_CBytes
-func _Cgo___CBytes([]byte) unsafe.Pointer
+//go:linkname C.__CBytes runtime.cgo_CBytes
+func C.__CBytes([]byte) unsafe.Pointer
 
-func _Cgo_CBytes(b []byte) unsafe.Pointer {
-	return _Cgo___CBytes(b)
+func C.CBytes(b []byte) unsafe.Pointer {
+	return C.__CBytes(b)
 }
 
-//go:linkname _Cgo___get_errno_num runtime.cgo_errno
-func _Cgo___get_errno_num() uintptr
+//go:linkname C.__get_errno_num runtime.cgo_errno
+func C.__get_errno_num() uintptr
 
-func _Cgo___get_errno() error {
-	return syscall.Errno(_Cgo___get_errno_num())
+func C.__get_errno() error {
+	return syscall.Errno(C.__get_errno_num())
 }
 
 type (
-	_Cgo_char      uint8
-	_Cgo_schar     int8
-	_Cgo_uchar     uint8
-	_Cgo_short     int16
-	_Cgo_ushort    uint16
-	_Cgo_int       int32
-	_Cgo_uint      uint32
-	_Cgo_long      int32
-	_Cgo_ulong     uint32
-	_Cgo_longlong  int64
-	_Cgo_ulonglong uint64
+	C.char      uint8
+	C.schar     int8
+	C.uchar     uint8
+	C.short     int16
+	C.ushort    uint16
+	C.int       int32
+	C.uint      uint32
+	C.long      int32
+	C.ulong     uint32
+	C.longlong  int64
+	C.ulonglong uint64
 )
-type _Cgo_myint = _Cgo_int
-type _Cgo_struct_point2d_t struct {
-	x _Cgo_int
-	y _Cgo_int
+type C.myint = C.int
+type C.struct_point2d_t struct {
+	x C.int
+	y C.int
 }
-type _Cgo_point2d_t = _Cgo_struct_point2d_t
-type _Cgo_struct_point3d struct {
-	x _Cgo_int
-	y _Cgo_int
-	z _Cgo_int
+type C.point2d_t = C.struct_point2d_t
+type C.struct_point3d struct {
+	x C.int
+	y C.int
+	z C.int
 }
-type _Cgo_point3d_t = _Cgo_struct_point3d
-type _Cgo_struct_type1 struct {
-	_type   _Cgo_int
-	__type  _Cgo_int
-	___type _Cgo_int
+type C.point3d_t = C.struct_point3d
+type C.struct_type1 struct {
+	_type   C.int
+	__type  C.int
+	___type C.int
 }
-type _Cgo_struct_type2 struct{ _type _Cgo_int }
-type _Cgo_union_union1_t struct{ i _Cgo_int }
-type _Cgo_union1_t = _Cgo_union_union1_t
-type _Cgo_union_union3_t struct{ $union uint64 }
+type C.struct_type2 struct{ _type C.int }
+type C.union_union1_t struct{ i C.int }
+type C.union1_t = C.union_union1_t
+type C.union_union3_t struct{ $union uint64 }
 
-func (union *_Cgo_union_union3_t) unionfield_i() *_Cgo_int {
-	return (*_Cgo_int)(unsafe.Pointer(&union.$union))
-}
-func (union *_Cgo_union_union3_t) unionfield_d() *float64 {
+func (union *C.union_union3_t) unionfield_i() *C.int { return (*C.int)(unsafe.Pointer(&union.$union)) }
+func (union *C.union_union3_t) unionfield_d() *float64 {
 	return (*float64)(unsafe.Pointer(&union.$union))
 }
-func (union *_Cgo_union_union3_t) unionfield_s() *_Cgo_short {
-	return (*_Cgo_short)(unsafe.Pointer(&union.$union))
+func (union *C.union_union3_t) unionfield_s() *C.short {
+	return (*C.short)(unsafe.Pointer(&union.$union))
 }
 
-type _Cgo_union3_t = _Cgo_union_union3_t
-type _Cgo_union_union2d struct{ $union [2]uint64 }
+type C.union3_t = C.union_union3_t
+type C.union_union2d struct{ $union [2]uint64 }
 
-func (union *_Cgo_union_union2d) unionfield_i() *_Cgo_int {
-	return (*_Cgo_int)(unsafe.Pointer(&union.$union))
-}
-func (union *_Cgo_union_union2d) unionfield_d() *[2]float64 {
+func (union *C.union_union2d) unionfield_i() *C.int { return (*C.int)(unsafe.Pointer(&union.$union)) }
+func (union *C.union_union2d) unionfield_d() *[2]float64 {
 	return (*[2]float64)(unsafe.Pointer(&union.$union))
 }
 
-type _Cgo_union2d_t = _Cgo_union_union2d
-type _Cgo_union_unionarray_t struct{ arr [10]_Cgo_uchar }
-type _Cgo_unionarray_t = _Cgo_union_unionarray_t
-type _Cgo__Ctype_union___0 struct{ $union [3]uint32 }
+type C.union2d_t = C.union_union2d
+type C.union_unionarray_t struct{ arr [10]C.uchar }
+type C.unionarray_t = C.union_unionarray_t
+type C._Ctype_union___0 struct{ $union [3]uint32 }
 
-func (union *_Cgo__Ctype_union___0) unionfield_area() *_Cgo_point2d_t {
-	return (*_Cgo_point2d_t)(unsafe.Pointer(&union.$union))
+func (union *C._Ctype_union___0) unionfield_area() *C.point2d_t {
+	return (*C.point2d_t)(unsafe.Pointer(&union.$union))
 }
-func (union *_Cgo__Ctype_union___0) unionfield_solid() *_Cgo_point3d_t {
-	return (*_Cgo_point3d_t)(unsafe.Pointer(&union.$union))
+func (union *C._Ctype_union___0) unionfield_solid() *C.point3d_t {
+	return (*C.point3d_t)(unsafe.Pointer(&union.$union))
 }
 
-type _Cgo_struct_struct_nested_t struct {
-	begin _Cgo_point2d_t
-	end   _Cgo_point2d_t
-	tag   _Cgo_int
+type C.struct_struct_nested_t struct {
+	begin C.point2d_t
+	end   C.point2d_t
+	tag   C.int
 
-	coord _Cgo__Ctype_union___0
+	coord C._Ctype_union___0
 }
-type _Cgo_struct_nested_t = _Cgo_struct_struct_nested_t
-type _Cgo_union_union_nested_t struct{ $union [2]uint64 }
+type C.struct_nested_t = C.struct_struct_nested_t
+type C.union_union_nested_t struct{ $union [2]uint64 }
 
-func (union *_Cgo_union_union_nested_t) unionfield_point() *_Cgo_point3d_t {
-	return (*_Cgo_point3d_t)(unsafe.Pointer(&union.$union))
+func (union *C.union_union_nested_t) unionfield_point() *C.point3d_t {
+	return (*C.point3d_t)(unsafe.Pointer(&union.$union))
 }
-func (union *_Cgo_union_union_nested_t) unionfield_array() *_Cgo_unionarray_t {
-	return (*_Cgo_unionarray_t)(unsafe.Pointer(&union.$union))
+func (union *C.union_union_nested_t) unionfield_array() *C.unionarray_t {
+	return (*C.unionarray_t)(unsafe.Pointer(&union.$union))
 }
-func (union *_Cgo_union_union_nested_t) unionfield_thing() *_Cgo_union3_t {
-	return (*_Cgo_union3_t)(unsafe.Pointer(&union.$union))
+func (union *C.union_union_nested_t) unionfield_thing() *C.union3_t {
+	return (*C.union3_t)(unsafe.Pointer(&union.$union))
 }
 
-type _Cgo_union_nested_t = _Cgo_union_union_nested_t
-type _Cgo_enum_option = _Cgo_int
-type _Cgo_option_t = _Cgo_enum_option
-type _Cgo_enum_option2_t = _Cgo_uint
-type _Cgo_option2_t = _Cgo_enum_option2_t
-type _Cgo_struct_types_t struct {
+type C.union_nested_t = C.union_union_nested_t
+type C.enum_option = C.int
+type C.option_t = C.enum_option
+type C.enum_option2_t = C.uint
+type C.option2_t = C.enum_option2_t
+type C.struct_types_t struct {
 	f   float32
 	d   float64
-	ptr *_Cgo_int
+	ptr *C.int
 }
-type _Cgo_types_t = _Cgo_struct_types_t
-type _Cgo_myIntArray = [10]_Cgo_int
-type _Cgo_struct_bitfield_t struct {
-	start        _Cgo_uchar
-	__bitfield_1 _Cgo_uchar
+type C.types_t = C.struct_types_t
+type C.myIntArray = [10]C.int
+type C.struct_bitfield_t struct {
+	start        C.uchar
+	__bitfield_1 C.uchar
 
-	d _Cgo_uchar
-	e _Cgo_uchar
+	d C.uchar
+	e C.uchar
 }
 
-func (s *_Cgo_struct_bitfield_t) bitfield_a() _Cgo_uchar { return s.__bitfield_1 & 0x1f }
-func (s *_Cgo_struct_bitfield_t) set_bitfield_a(value _Cgo_uchar) {
+func (s *C.struct_bitfield_t) bitfield_a() C.uchar { return s.__bitfield_1 & 0x1f }
+func (s *C.struct_bitfield_t) set_bitfield_a(value C.uchar) {
 	s.__bitfield_1 = s.__bitfield_1&^0x1f | value&0x1f<<0
 }
-func (s *_Cgo_struct_bitfield_t) bitfield_b() _Cgo_uchar {
+func (s *C.struct_bitfield_t) bitfield_b() C.uchar {
 	return s.__bitfield_1 >> 5 & 0x1
 }
-func (s *_Cgo_struct_bitfield_t) set_bitfield_b(value _Cgo_uchar) {
+func (s *C.struct_bitfield_t) set_bitfield_b(value C.uchar) {
 	s.__bitfield_1 = s.__bitfield_1&^0x20 | value&0x1<<5
 }
-func (s *_Cgo_struct_bitfield_t) bitfield_c() _Cgo_uchar {
+func (s *C.struct_bitfield_t) bitfield_c() C.uchar {
 	return s.__bitfield_1 >> 6
 }
-func (s *_Cgo_struct_bitfield_t) set_bitfield_c(value _Cgo_uchar,
+func (s *C.struct_bitfield_t) set_bitfield_c(value C.uchar,
 
 ) { s.__bitfield_1 = s.__bitfield_1&0x3f | value<<6 }
 
-type _Cgo_bitfield_t = _Cgo_struct_bitfield_t
+type C.bitfield_t = C.struct_bitfield_t

compileopts/config.go

@@ -8,25 +8,12 @@ import (
 	"os"
 	"path/filepath"
 	"regexp"
-	"slices"
-	"strconv"
 	"strings"
 
 	"github.com/google/shlex"
 	"github.com/tinygo-org/tinygo/goenv"
 )
 
-// Library versions. Whenever an existing library is changed, this number should
-// be added/increased so that existing caches are invalidated.
-//
-// (This is a bit of a layering violation, this should really be part of the
-// builder.Library struct but that's hard to do since we want to know the
-// library path in advance in several places).
-var libVersions = map[string]int{
-	"musl":  3,
-	"bdwgc": 2,
-}
-
 // Config keeps all configuration affecting the build in a single struct.
 type Config struct {
 	Options        *Options
@@ -61,15 +48,13 @@ func (c *Config) BuildMode() string {
 // RISC-V processor, that could be "+a,+c,+m". For many targets, an empty list
 // will be returned.
 func (c *Config) Features() string {
-	var features string
 	if c.Target.Features == "" {
-		features = c.Options.LLVMFeatures
-	} else if c.Options.LLVMFeatures == "" {
-		features = c.Target.Features
-	} else {
-		features = c.Target.Features + "," + c.Options.LLVMFeatures
+		return c.Options.LLVMFeatures
 	}
-	return patchFeatures(features)
+	if c.Options.LLVMFeatures == "" {
+		return c.Target.Features
+	}
+	return c.Target.Features + "," + c.Options.LLVMFeatures
 }
 
 // ABI returns the -mabi= flag for this target (like -mabi=lp64). A zero-length
@@ -114,11 +99,6 @@ func (c *Config) BuildTags() []string {
 		"math_big_pure_go",                           // to get math/big to work
 		"gc." + c.GC(), "scheduler." + c.Scheduler(), // used inside the runtime package
 		"serial." + c.Serial()}...) // used inside the machine package
-	switch c.Scheduler() {
-	case "threads", "cores":
-	default:
-		tags = append(tags, "tinygo.unicore")
-	}
 	for i := 1; i <= c.GoMinorVersion; i++ {
 		tags = append(tags, fmt.Sprintf("go1.%d", i))
 	}
@@ -142,8 +122,14 @@ func (c *Config) GC() string {
 // that can be traced by the garbage collector.
 func (c *Config) NeedsStackObjects() bool {
 	switch c.GC() {
-	case "conservative", "custom", "precise", "boehm":
-		return slices.Contains(c.BuildTags(), "tinygo.wasm")
+	case "conservative", "custom", "precise":
+		for _, tag := range c.BuildTags() {
+			if tag == "tinygo.wasm" {
+				return true
+			}
+		}
+
+		return false
 	default:
 		return false
 	}
@@ -223,7 +209,7 @@ func (c *Config) StackSize() uint64 {
 
 // MaxStackAlloc returns the size of the maximum allocation to put on the stack vs heap.
 func (c *Config) MaxStackAlloc() uint64 {
-	if c.StackSize() >= 16*1024 {
+	if c.StackSize() > 32*1024 {
 		return 1024
 	}
 
@@ -242,7 +228,7 @@ func (c *Config) RP2040BootPatch() bool {
 // Return a canonicalized architecture name, so we don't have to deal with arm*
 // vs thumb* vs arm64.
 func CanonicalArchName(triple string) string {
-	arch, _, _ := strings.Cut(triple, "-")
+	arch := strings.Split(triple, "-")[0]
 	if arch == "arm64" {
 		return "aarch64"
 	}
@@ -261,18 +247,10 @@ func MuslArchitecture(triple string) string {
 	return CanonicalArchName(triple)
 }
 
-// Returns true if the libc needs to include malloc, for the libcs where this
-// matters.
-func (c *Config) LibcNeedsMalloc() bool {
-	if c.GC() == "boehm" && c.Target.Libc == "wasi-libc" {
-		return true
-	}
-	return false
-}
-
-// LibraryPath returns the path to the library build directory. The path will be
-// a library path in the cache directory (which might not yet be built).
-func (c *Config) LibraryPath(name string) string {
+// LibcPath returns the path to the libc directory. The libc path will be either
+// a precompiled libc shipped with a TinyGo build, or a libc path in the cache
+// directory (which might not yet be built).
+func (c *Config) LibcPath(name string) (path string, precompiled bool) {
 	archname := c.Triple()
 	if c.CPU() != "" {
 		archname += "-" + c.CPU()
@@ -283,24 +261,18 @@ func (c *Config) LibraryPath(name string) string {
 	if c.Target.SoftFloat {
 		archname += "-softfloat"
 	}
-	if name == "bdwgc" {
-		// Boehm GC is compiled against a particular libc.
-		archname += "-" + c.Target.Libc
-	}
 
-	// Append a version string, if this library has a version.
-	if v, ok := libVersions[name]; ok {
-		archname += "-v" + strconv.Itoa(v)
-	}
-
-	options := ""
-	if c.LibcNeedsMalloc() {
-		options += "+malloc"
+	// Try to load a precompiled library.
+	precompiledDir := filepath.Join(goenv.Get("TINYGOROOT"), "pkg", archname, name)
+	if _, err := os.Stat(precompiledDir); err == nil {
+		// Found a precompiled library for this OS/architecture. Return the path
+		// directly.
+		return precompiledDir, true
 	}
 
 	// No precompiled library found. Determine the path name that will be used
 	// in the build cache.
-	return filepath.Join(goenv.Get("GOCACHE"), name+options+"-"+archname)
+	return filepath.Join(goenv.Get("GOCACHE"), name+"-"+archname), false
 }
 
 // DefaultBinaryExtension returns the default extension for binaries, such as
@@ -343,13 +315,65 @@ func (c *Config) CFlags(libclang bool) []string {
 			"-resource-dir="+resourceDir,
 		)
 	}
-	cflags = append(cflags, c.LibcCFlags()...)
+	switch c.Target.Libc {
+	case "darwin-libSystem":
+		root := goenv.Get("TINYGOROOT")
+		cflags = append(cflags,
+			"-nostdlibinc",
+			"-isystem", filepath.Join(root, "lib/macos-minimal-sdk/src/usr/include"),
+		)
+	case "picolibc":
+		root := goenv.Get("TINYGOROOT")
+		picolibcDir := filepath.Join(root, "lib", "picolibc", "newlib", "libc")
+		path, _ := c.LibcPath("picolibc")
+		cflags = append(cflags,
+			"-nostdlibinc",
+			"-isystem", filepath.Join(path, "include"),
+			"-isystem", filepath.Join(picolibcDir, "include"),
+			"-isystem", filepath.Join(picolibcDir, "tinystdio"),
+			"-D__PICOLIBC_ERRNO_FUNCTION=__errno_location",
+		)
+	case "musl":
+		root := goenv.Get("TINYGOROOT")
+		path, _ := c.LibcPath("musl")
+		arch := MuslArchitecture(c.Triple())
+		cflags = append(cflags,
+			"-nostdlibinc",
+			"-isystem", filepath.Join(path, "include"),
+			"-isystem", filepath.Join(root, "lib", "musl", "arch", arch),
+			"-isystem", filepath.Join(root, "lib", "musl", "arch", "generic"),
+			"-isystem", filepath.Join(root, "lib", "musl", "include"),
+		)
+	case "wasi-libc":
+		root := goenv.Get("TINYGOROOT")
+		cflags = append(cflags,
+			"-nostdlibinc",
+			"-isystem", root+"/lib/wasi-libc/sysroot/include")
+	case "wasmbuiltins":
+		// nothing to add (library is purely for builtins)
+	case "mingw-w64":
+		root := goenv.Get("TINYGOROOT")
+		path, _ := c.LibcPath("mingw-w64")
+		cflags = append(cflags,
+			"-nostdlibinc",
+			"-isystem", filepath.Join(path, "include"),
+			"-isystem", filepath.Join(root, "lib", "mingw-w64", "mingw-w64-headers", "crt"),
+			"-isystem", filepath.Join(root, "lib", "mingw-w64", "mingw-w64-headers", "defaults", "include"),
+			"-D_UCRT",
+		)
+	case "":
+		// No libc specified, nothing to add.
+	default:
+		// Incorrect configuration. This could be handled in a better way, but
+		// usually this will be found by developers (not by TinyGo users).
+		panic("unknown libc: " + c.Target.Libc)
+	}
 	// Always emit debug information. It is optionally stripped at link time.
 	cflags = append(cflags, "-gdwarf-4")
 	// Use the same optimization level as TinyGo.
 	cflags = append(cflags, "-O"+c.Options.Opt)
 	// Set the LLVM target triple.
-	cflags = append(cflags, "--target="+ClangTriple(c.Triple()))
+	cflags = append(cflags, "--target="+c.Triple())
 	// Set the -mcpu (or similar) flag.
 	if c.Target.CPU != "" {
 		if c.GOARCH() == "amd64" || c.GOARCH() == "386" {
@@ -370,80 +394,6 @@ func (c *Config) CFlags(libclang bool) []string {
 	return cflags
 }
 
-// LibcCFlags returns the C compiler flags for the configured libc.
-// It only uses flags that are part of the libc path (triple, cpu, abi, libc
-// name) so it can safely be used to compile another C library.
-func (c *Config) LibcCFlags() []string {
-	switch c.Target.Libc {
-	case "darwin-libSystem":
-		root := goenv.Get("TINYGOROOT")
-		return []string{
-			"-nostdlibinc",
-			"-isystem", filepath.Join(root, "lib/macos-minimal-sdk/src/usr/include"),
-		}
-	case "picolibc":
-		root := goenv.Get("TINYGOROOT")
-		picolibcDir := filepath.Join(root, "lib", "picolibc", "newlib", "libc")
-		path := c.LibraryPath("picolibc")
-		return []string{
-			"-nostdlibinc",
-			"-isystem", filepath.Join(path, "include"),
-			"-isystem", filepath.Join(picolibcDir, "include"),
-			"-isystem", filepath.Join(picolibcDir, "tinystdio"),
-			"-D__PICOLIBC_ERRNO_FUNCTION=__errno_location",
-		}
-	case "musl":
-		root := goenv.Get("TINYGOROOT")
-		path := c.LibraryPath("musl")
-		arch := MuslArchitecture(c.Triple())
-		return []string{
-			"-nostdlibinc",
-			"-isystem", filepath.Join(path, "include"),
-			"-isystem", filepath.Join(root, "lib", "musl", "arch", arch),
-			"-isystem", filepath.Join(root, "lib", "musl", "arch", "generic"),
-			"-isystem", filepath.Join(root, "lib", "musl", "include"),
-		}
-	case "wasi-libc":
-		path := c.LibraryPath("wasi-libc")
-		return []string{
-			"-nostdlibinc",
-			"-isystem", filepath.Join(path, "include"),
-		}
-	case "wasmbuiltins":
-		// nothing to add (library is purely for builtins)
-		return nil
-	case "mingw-w64":
-		root := goenv.Get("TINYGOROOT")
-		path := c.LibraryPath("mingw-w64")
-		cflags := []string{
-			"-nostdlibinc",
-			"-isystem", filepath.Join(path, "include"),
-			"-isystem", filepath.Join(root, "lib", "mingw-w64", "mingw-w64-headers", "crt"),
-			"-isystem", filepath.Join(root, "lib", "mingw-w64", "mingw-w64-headers", "include"),
-			"-isystem", filepath.Join(root, "lib", "mingw-w64", "mingw-w64-headers", "defaults", "include"),
-		}
-		if c.GOARCH() == "386" {
-			cflags = append(cflags,
-				"-D__MSVCRT_VERSION__=0x700", // Microsoft Visual C++ .NET 2002
-				"-D_WIN32_WINNT=0x0501",      // target Windows XP
-			)
-		} else {
-			cflags = append(cflags,
-				"-D_UCRT",
-				"-D_WIN32_WINNT=0x0a00", // target Windows 10
-			)
-		}
-		return cflags
-	case "":
-		// No libc specified, nothing to add.
-		return nil
-	default:
-		// Incorrect configuration. This could be handled in a better way, but
-		// usually this will be found by developers (not by TinyGo users).
-		panic("unknown libc: " + c.Target.Libc)
-	}
-}
-
 // LDFlags returns the flags to pass to the linker. A few more flags are needed
 // (like the one for the compiler runtime), but this represents the majority of
 // the flags.
@@ -463,22 +413,6 @@ func (c *Config) LDFlags() []string {
 	return ldflags
 }
 
-// LinkerFlavor returns how the configured linker should be driven.
-// Usually this is derived from GOOS, but targets may override it explicitly.
-func (c *Config) LinkerFlavor() string {
-	if c.Target.LinkerFlavor != "" {
-		return c.Target.LinkerFlavor
-	}
-	switch c.GOOS() {
-	case "windows":
-		return "coff"
-	case "darwin":
-		return "darwin"
-	default:
-		return "gnu"
-	}
-}
-
 // ExtraFiles returns the list of extra files to be built and linked with the
 // executable. This can include extra C and assembly files.
 func (c *Config) ExtraFiles() []string {
@@ -549,10 +483,10 @@ func (c *Config) Programmer() (method, openocdInterface string) {
 	case "":
 		// No configuration supplied.
 		return c.Target.FlashMethod, c.Target.OpenOCDInterface
-	case "openocd", "msd", "command", "adb":
+	case "openocd", "msd", "command":
 		// The -programmer flag only specifies the flash method.
 		return c.Options.Programmer, c.Target.OpenOCDInterface
-	case "bmp", "probe-rs":
+	case "bmp":
 		// The -programmer flag only specifies the flash method.
 		return c.Options.Programmer, ""
 	default:

compileopts/features_default.go

@@ -1,9 +0,0 @@
-//go:build !llvm22 && !llvm14 && !llvm15 && !llvm16 && !llvm17 && !llvm18 && !llvm19
-
-package compileopts
-
-// patchFeatures applies LLVM-version-specific feature name mappings.
-// For LLVM 20/21, features in the target JSON files are already correct.
-func patchFeatures(features string) string {
-	return features
-}

compileopts/features_llvm22.go

@@ -1,26 +0,0 @@
-//go:build llvm22
-
-package compileopts
-
-import "strings"
-
-// patchFeatures applies LLVM-version-specific feature name mappings.
-// LLVM 22 renamed several Xtensa target features.
-func patchFeatures(features string) string {
-	// Xtensa feature renames in LLVM 22:
-	//   atomctl → (removed, no direct replacement)
-	//   memctl  → (removed, no direct replacement)
-	//   esp32s3 → esp32s3ops
-	//   timerint → timers3 (for esp32/esp32s3) or timers1 (for esp8266)
-	// Since we can't distinguish which timer variant at this level,
-	// just remove the obsolete features. The CPU definition already
-	// implies the correct features in LLVM 22.
-	replacer := strings.NewReplacer(
-		"+atomctl,", "",
-		"+memctl,", "",
-		"+esp32s3,", "+esp32s3ops,",
-		"+timerint,", "",
-		",+timerint", "",
-	)
-	return replacer.Replace(features)
-}

compileopts/features_pre20.go

@@ -1,16 +0,0 @@
-//go:build llvm14 || llvm15 || llvm16 || llvm17 || llvm18 || llvm19
-
-package compileopts
-
-import "strings"
-
-// patchFeatures applies LLVM-version-specific feature name mappings.
-// LLVM 19 and earlier do not have +bulk-memory-opt or
-// +call-indirect-overlong for WebAssembly (added in LLVM 20).
-func patchFeatures(features string) string {
-	features = strings.ReplaceAll(features, ",+bulk-memory-opt", "")
-	features = strings.ReplaceAll(features, "+bulk-memory-opt,", "")
-	features = strings.ReplaceAll(features, ",+call-indirect-overlong", "")
-	features = strings.ReplaceAll(features, "+call-indirect-overlong,", "")
-	return features
-}

compileopts/finalizer_coverage_test.go

@@ -1,65 +0,0 @@
-package compileopts
-
-import (
-	"go/build/constraint"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-// TestFinalizerRunnerSchedulerCoverage verifies that each scheduler selects one runner file.
-// It uses validSchedulerOptions so new schedulers are included.
-func TestFinalizerRunnerSchedulerCoverage(t *testing.T) {
-	files := []string{
-		"gc_finalizer_sched.go",
-		"gc_finalizer_sched_none.go",
-		"gc_finalizer_sched_other.go",
-	}
-	exprs := make([]constraint.Expr, len(files))
-	for i, name := range files {
-		exprs[i] = readBuildConstraint(t, filepath.Join("..", "src", "runtime", name))
-	}
-
-	for _, sched := range validSchedulerOptions {
-		// The finalizer table exists under block GCs.
-		// gc.conservative satisfies the GC condition in every constraint.
-		tags := map[string]bool{
-			"gc.conservative":    true,
-			"scheduler." + sched: true,
-		}
-		var matched []string
-		for i, expr := range exprs {
-			if expr.Eval(func(tag string) bool { return tags[tag] }) {
-				matched = append(matched, files[i])
-			}
-		}
-		if len(matched) != 1 {
-			t.Errorf("scheduler.%s: spawnFinalizerRunner defined in %d files %v, want exactly 1",
-				sched, len(matched), matched)
-		}
-	}
-}
-
-func readBuildConstraint(t *testing.T, path string) constraint.Expr {
-	t.Helper()
-	data, err := os.ReadFile(path)
-	if err != nil {
-		t.Fatal(err)
-	}
-	for _, line := range strings.Split(string(data), "\n") {
-		line = strings.TrimSpace(line)
-		if constraint.IsGoBuild(line) {
-			expr, err := constraint.Parse(line)
-			if err != nil {
-				t.Fatalf("%s: %v", path, err)
-			}
-			return expr
-		}
-		if line != "" && !strings.HasPrefix(line, "//") {
-			break // reached code before any //go:build line
-		}
-	}
-	t.Fatalf("%s: no //go:build line found", path)
-	return nil
-}

compileopts/options.go

@@ -3,15 +3,14 @@ package compileopts
 import (
 	"fmt"
 	"regexp"
-	"slices"
 	"strings"
 	"time"
 )
 
 var (
 	validBuildModeOptions     = []string{"default", "c-shared", "wasi-legacy"}
-	validGCOptions            = []string{"none", "leaking", "conservative", "custom", "precise", "boehm"}
-	validSchedulerOptions     = []string{"none", "tasks", "asyncify", "threads", "cores"}
+	validGCOptions            = []string{"none", "leaking", "conservative", "custom", "precise"}
+	validSchedulerOptions     = []string{"none", "tasks", "asyncify"}
 	validSerialOptions        = []string{"none", "uart", "usb", "rtt"}
 	validPrintSizeOptions     = []string{"none", "short", "full", "html"}
 	validPanicStrategyOptions = []string{"print", "trap"}
@@ -22,53 +21,50 @@ var (
 // usually passed from the command line, but can also be passed in environment
 // variables for example.
 type Options struct {
-	GOOS                    string // environment variable
-	GOARCH                  string // environment variable
-	GOARM                   string // environment variable (only used with GOARCH=arm)
-	GOMIPS                  string // environment variable (only used with GOARCH=mips and GOARCH=mipsle)
-	Directory               string // working dir, leave it unset to use the current working dir
-	Target                  string
-	BuildMode               string // -buildmode flag
-	Opt                     string
-	GC                      string
-	PanicStrategy           string
-	Scheduler               string
-	StackSize               uint64 // goroutine stack size (if none could be automatically determined)
-	Serial                  string
-	Work                    bool // -work flag to print temporary build directory
-	InterpTimeout           time.Duration
-	InterpMaxLoopIterations int
-	PrintIR                 bool
-	DumpSSA                 bool
-	VerifyIR                bool
-	SkipDWARF               bool
-	PrintCommands           func(cmd string, args ...string) `json:"-"`
-	Semaphore               chan struct{}                    `json:"-"` // -p flag controls cap
-	Debug                   bool
-	Nobounds                bool
-	PrintSizes              string
-	PrintAllocs             *regexp.Regexp // regexp string
-	PrintAllocsCover        bool           // emit allocs in go coverage tool format
-	PrintStacks             bool
-	Tags                    []string
-	GlobalValues            map[string]map[string]string // map[pkgpath]map[varname]value
-	TestConfig              TestConfig
-	Programmer              string
-	OpenOCDCommands         []string
-	LLVMFeatures            string
-	Monitor                 bool
-	BaudRate                int
-	Timeout                 time.Duration
-	WITPackage              string // pass through to wasm-tools component embed invocation
-	WITWorld                string // pass through to wasm-tools component embed -w option
-	ExtLDFlags              []string
-	GoCompatibility         bool // enable to check for Go version compatibility
+	GOOS            string // environment variable
+	GOARCH          string // environment variable
+	GOARM           string // environment variable (only used with GOARCH=arm)
+	GOMIPS          string // environment variable (only used with GOARCH=mips and GOARCH=mipsle)
+	Directory       string // working dir, leave it unset to use the current working dir
+	Target          string
+	BuildMode       string // -buildmode flag
+	Opt             string
+	GC              string
+	PanicStrategy   string
+	Scheduler       string
+	StackSize       uint64 // goroutine stack size (if none could be automatically determined)
+	Serial          string
+	Work            bool // -work flag to print temporary build directory
+	InterpTimeout   time.Duration
+	PrintIR         bool
+	DumpSSA         bool
+	VerifyIR        bool
+	SkipDWARF       bool
+	PrintCommands   func(cmd string, args ...string) `json:"-"`
+	Semaphore       chan struct{}                    `json:"-"` // -p flag controls cap
+	Debug           bool
+	PrintSizes      string
+	PrintAllocs     *regexp.Regexp // regexp string
+	PrintStacks     bool
+	Tags            []string
+	GlobalValues    map[string]map[string]string // map[pkgpath]map[varname]value
+	TestConfig      TestConfig
+	Programmer      string
+	OpenOCDCommands []string
+	LLVMFeatures    string
+	PrintJSON       bool
+	Monitor         bool
+	BaudRate        int
+	Timeout         time.Duration
+	WITPackage      string // pass through to wasm-tools component embed invocation
+	WITWorld        string // pass through to wasm-tools component embed -w option
+	ExtLDFlags      []string
 }
 
 // Verify performs a validation on the given options, raising an error if options are not valid.
 func (o *Options) Verify() error {
 	if o.BuildMode != "" {
-		valid := slices.Contains(validBuildModeOptions, o.BuildMode)
+		valid := isInArray(validBuildModeOptions, o.BuildMode)
 		if !valid {
 			return fmt.Errorf(`invalid buildmode option '%s': valid values are %s`,
 				o.BuildMode,
@@ -76,7 +72,7 @@ func (o *Options) Verify() error {
 		}
 	}
 	if o.GC != "" {
-		valid := slices.Contains(validGCOptions, o.GC)
+		valid := isInArray(validGCOptions, o.GC)
 		if !valid {
 			return fmt.Errorf(`invalid gc option '%s': valid values are %s`,
 				o.GC,
@@ -85,7 +81,7 @@ func (o *Options) Verify() error {
 	}
 
 	if o.Scheduler != "" {
-		valid := slices.Contains(validSchedulerOptions, o.Scheduler)
+		valid := isInArray(validSchedulerOptions, o.Scheduler)
 		if !valid {
 			return fmt.Errorf(`invalid scheduler option '%s': valid values are %s`,
 				o.Scheduler,
@@ -94,7 +90,7 @@ func (o *Options) Verify() error {
 	}
 
 	if o.Serial != "" {
-		valid := slices.Contains(validSerialOptions, o.Serial)
+		valid := isInArray(validSerialOptions, o.Serial)
 		if !valid {
 			return fmt.Errorf(`invalid serial option '%s': valid values are %s`,
 				o.Serial,
@@ -103,7 +99,7 @@ func (o *Options) Verify() error {
 	}
 
 	if o.PrintSizes != "" {
-		valid := slices.Contains(validPrintSizeOptions, o.PrintSizes)
+		valid := isInArray(validPrintSizeOptions, o.PrintSizes)
 		if !valid {
 			return fmt.Errorf(`invalid size option '%s': valid values are %s`,
 				o.PrintSizes,
@@ -112,7 +108,7 @@ func (o *Options) Verify() error {
 	}
 
 	if o.PanicStrategy != "" {
-		valid := slices.Contains(validPanicStrategyOptions, o.PanicStrategy)
+		valid := isInArray(validPanicStrategyOptions, o.PanicStrategy)
 		if !valid {
 			return fmt.Errorf(`invalid panic option '%s': valid values are %s`,
 				o.PanicStrategy,
@@ -121,10 +117,19 @@ func (o *Options) Verify() error {
 	}
 
 	if o.Opt != "" {
-		if !slices.Contains(validOptOptions, o.Opt) {
+		if !isInArray(validOptOptions, o.Opt) {
 			return fmt.Errorf("invalid -opt=%s: valid values are %s", o.Opt, strings.Join(validOptOptions, ", "))
 		}
 	}
 
 	return nil
 }
+
+func isInArray(arr []string, item string) bool {
+	for _, i := range arr {
+		if i == item {
+			return true
+		}
+	}
+	return false
+}

compileopts/options_test.go

@@ -9,8 +9,8 @@ import (
 
 func TestVerifyOptions(t *testing.T) {
 
-	expectedGCError := errors.New(`invalid gc option 'incorrect': valid values are none, leaking, conservative, custom, precise, boehm`)
-	expectedSchedulerError := errors.New(`invalid scheduler option 'incorrect': valid values are none, tasks, asyncify, threads, cores`)
+	expectedGCError := errors.New(`invalid gc option 'incorrect': valid values are none, leaking, conservative, custom, precise`)
+	expectedSchedulerError := errors.New(`invalid scheduler option 'incorrect': valid values are none, tasks, asyncify`)
 	expectedPrintSizeError := errors.New(`invalid size option 'incorrect': valid values are none, short, full, html`)
 	expectedPanicStrategyError := errors.New(`invalid panic option 'incorrect': valid values are print, trap`)
 

compileopts/target.go

@@ -24,7 +24,6 @@ import (
 // https://github.com/shepmaster/rust-arduino-blink-led-no-core-with-cargo/blob/master/blink/arduino.json
 type TargetSpec struct {
 	Inherits         []string `json:"inherits,omitempty"`
-	InheritableOnly  bool     `json:"inheritable-only"` // this target is only meant to be inherited from, not used directly
 	Triple           string   `json:"llvm-target,omitempty"`
 	CPU              string   `json:"cpu,omitempty"`
 	ABI              string   `json:"target-abi,omitempty"` // roughly equivalent to -mabi= flag
@@ -38,8 +37,7 @@ type TargetSpec struct {
 	Scheduler        string   `json:"scheduler,omitempty"`
 	Serial           string   `json:"serial,omitempty"` // which serial output to use (uart, usb, none)
 	Linker           string   `json:"linker,omitempty"`
-	LinkerFlavor     string   `json:"linker-flavor,omitempty"` // how to drive the configured linker (for example: gnu, coff, darwin)
-	RTLib            string   `json:"rtlib,omitempty"`         // compiler runtime library (libgcc, compiler-rt)
+	RTLib            string   `json:"rtlib,omitempty"` // compiler runtime library (libgcc, compiler-rt)
 	Libc             string   `json:"libc,omitempty"`
 	AutoStackSize    *bool    `json:"automatic-stack-size,omitempty"` // Determine stack size automatically at compile time.
 	DefaultStackSize uint64   `json:"default-stack-size,omitempty"`   // Default stack size if the size couldn't be determined at compile time.
@@ -65,10 +63,6 @@ type TargetSpec struct {
 	OpenOCDCommands  []string `json:"openocd-commands,omitempty"`
 	OpenOCDVerify    *bool    `json:"openocd-verify,omitempty"` // enable verify when flashing with openocd
 	JLinkDevice      string   `json:"jlink-device,omitempty"`
-	ADBPreCommands   []string `json:"adb-pre-commands,omitempty"`
-	ADBPushRemote    string   `json:"adb-push-remote,omitempty"`
-	ADBPostCommands  []string `json:"adb-post-commands,omitempty"`
-	ProbeRSChip      string   `json:"probe-rs-chip,omitempty"`
 	CodeModel        string   `json:"code-model,omitempty"`
 	RelocationModel  string   `json:"relocation-model,omitempty"`
 	WITPackage       string   `json:"wit-package,omitempty"`
@@ -154,11 +148,6 @@ func (spec *TargetSpec) loadFromGivenStr(str string) error {
 
 // resolveInherits loads inherited targets, recursively.
 func (spec *TargetSpec) resolveInherits() error {
-	// Save InheritableOnly before resolving, since it must not propagate
-	// from parent to child (a board target should not become inheritable-only
-	// just because its parent processor target is).
-	inheritableOnly := spec.InheritableOnly
-
 	// First create a new spec with all the inherited properties.
 	newSpec := &TargetSpec{}
 	for _, name := range spec.Inherits {
@@ -184,29 +173,11 @@ func (spec *TargetSpec) resolveInherits() error {
 	}
 	*spec = *newSpec
 
-	// Restore InheritableOnly from the original spec, not from parents.
-	spec.InheritableOnly = inheritableOnly
-
 	return nil
 }
 
 // Load a target specification.
 func LoadTarget(options *Options) (*TargetSpec, error) {
-	if options.Target == "" && options.GOARCH == "wasm" {
-		// Set a specific target if we're building from a known GOOS/GOARCH
-		// combination that is defined in a target JSON file.
-		switch options.GOOS {
-		case "js":
-			options.Target = "wasm"
-		case "wasip1":
-			options.Target = "wasip1"
-		case "wasip2":
-			options.Target = "wasip2"
-		default:
-			return nil, errors.New("GOARCH=wasm but GOOS is not set correctly. Please set GOOS to js, wasip1, or wasip2.")
-		}
-	}
-
 	if options.Target == "" {
 		return defaultTarget(options)
 	}
@@ -253,17 +224,10 @@ func GetTargetSpecs() (map[string]*TargetSpec, error) {
 			continue
 		}
 		path := filepath.Join(dir, entry.Name())
-
 		spec, err := LoadTarget(&Options{Target: path})
 		if err != nil {
 			return nil, fmt.Errorf("could not list target: %w", err)
 		}
-
-		if spec.InheritableOnly {
-			// Skip targets that are only meant to be inherited from, not used directly.
-			continue
-		}
-
 		if spec.FlashMethod == "" && spec.FlashCommand == "" && spec.Emulator == "" {
 			// This doesn't look like a regular target file, but rather like
 			// a parent target (such as targets/cortex-m.json).
@@ -283,6 +247,8 @@ func defaultTarget(options *Options) (*TargetSpec, error) {
 		GOOS:             options.GOOS,
 		GOARCH:           options.GOARCH,
 		BuildTags:        []string{options.GOOS, options.GOARCH},
+		GC:               "precise",
+		Scheduler:        "tasks",
 		Linker:           "cc",
 		DefaultStackSize: 1024 * 64, // 64kB
 		GDB:              []string{"gdb"},
@@ -390,7 +356,17 @@ func defaultTarget(options *Options) (*TargetSpec, error) {
 			return nil, fmt.Errorf("invalid GOMIPS=%s: must be hardfloat or softfloat", options.GOMIPS)
 		}
 	case "wasm":
-		return nil, fmt.Errorf("GOARCH=wasm but GOOS is unset. Please set GOOS to js, wasip1, or wasip2.")
+		llvmarch = "wasm32"
+		spec.CPU = "generic"
+		spec.Features = "+bulk-memory,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types"
+		spec.BuildTags = append(spec.BuildTags, "tinygo.wasm")
+		spec.CFlags = append(spec.CFlags,
+			"-mbulk-memory",
+			"-mnontrapping-fptoint",
+			"-mno-multivalue",
+			"-mno-reference-types",
+			"-msign-ext",
+		)
 	default:
 		return nil, fmt.Errorf("unknown GOARCH=%s", options.GOARCH)
 	}
@@ -400,13 +376,11 @@ func defaultTarget(options *Options) (*TargetSpec, error) {
 	llvmvendor := "unknown"
 	switch options.GOOS {
 	case "darwin":
-		spec.GC = "boehm"
 		platformVersion := "10.12.0"
 		if options.GOARCH == "arm64" {
 			platformVersion = "11.0.0" // first macosx platform with arm64 support
 		}
 		llvmvendor = "apple"
-		spec.Scheduler = "threads"
 		spec.Linker = "ld.lld"
 		spec.Libc = "darwin-libSystem"
 		// Use macosx* instead of darwin, otherwise darwin/arm64 will refer to
@@ -420,13 +394,10 @@ func defaultTarget(options *Options) (*TargetSpec, error) {
 		)
 		spec.ExtraFiles = append(spec.ExtraFiles,
 			"src/internal/futex/futex_darwin.c",
-			"src/internal/task/task_threads.c",
 			"src/runtime/os_darwin.c",
 			"src/runtime/runtime_unix.c",
 			"src/runtime/signal.c")
 	case "linux":
-		spec.GC = "boehm"
-		spec.Scheduler = "threads"
 		spec.Linker = "ld.lld"
 		spec.RTLib = "compiler-rt"
 		spec.Libc = "musl"
@@ -447,40 +418,27 @@ func defaultTarget(options *Options) (*TargetSpec, error) {
 		}
 		spec.ExtraFiles = append(spec.ExtraFiles,
 			"src/internal/futex/futex_linux.c",
-			"src/internal/task/task_threads.c",
 			"src/runtime/runtime_unix.c",
 			"src/runtime/signal.c")
 	case "windows":
-		spec.GC = "boehm"
-		spec.Scheduler = "tasks"
 		spec.Linker = "ld.lld"
 		spec.Libc = "mingw-w64"
+		// Note: using a medium code model, low image base and no ASLR
+		// because Go doesn't really need those features. ASLR patches
+		// around issues for unsafe languages like C/C++ that are not
+		// normally present in Go (without explicitly opting in).
+		// For more discussion:
+		// https://groups.google.com/g/Golang-nuts/c/Jd9tlNc6jUE/m/Zo-7zIP_m3MJ?pli=1
 		switch options.GOARCH {
-		case "386":
-			spec.LDFlags = append(spec.LDFlags,
-				"-m", "i386pe",
-				"--major-os-version", "4",
-				"--major-subsystem-version", "4",
-			)
-			// __udivdi3 is not present in ucrt it seems.
-			spec.RTLib = "compiler-rt"
 		case "amd64":
-			// Note: using a medium code model, low image base and no ASLR
-			// because Go doesn't really need those features. ASLR patches
-			// around issues for unsafe languages like C/C++ that are not
-			// normally present in Go (without explicitly opting in).
-			// For more discussion:
-			// https://groups.google.com/g/Golang-nuts/c/Jd9tlNc6jUE/m/Zo-7zIP_m3MJ?pli=1
 			spec.LDFlags = append(spec.LDFlags,
 				"-m", "i386pep",
 				"--image-base", "0x400000",
 			)
-			spec.RTLib = "compiler-rt"
 		case "arm64":
 			spec.LDFlags = append(spec.LDFlags,
 				"-m", "arm64pe",
 			)
-			spec.RTLib = "compiler-rt"
 		}
 		spec.LDFlags = append(spec.LDFlags,
 			"-Bdynamic",
@@ -488,20 +446,27 @@ func defaultTarget(options *Options) (*TargetSpec, error) {
 			"--no-insert-timestamp",
 			"--no-dynamicbase",
 		)
+	case "wasip1":
+		spec.GC = "" // use default GC
+		spec.Scheduler = "asyncify"
+		spec.Linker = "wasm-ld"
+		spec.RTLib = "compiler-rt"
+		spec.Libc = "wasi-libc"
+		spec.DefaultStackSize = 1024 * 64 // 64kB
+		spec.LDFlags = append(spec.LDFlags,
+			"--stack-first",
+			"--no-demangle",
+		)
+		spec.Emulator = "wasmtime run --dir={tmpDir}::/tmp {}"
 		spec.ExtraFiles = append(spec.ExtraFiles,
-			"src/runtime/runtime_windows.c")
-	case "wasm", "wasip1", "wasip2":
-		return nil, fmt.Errorf("GOOS=%s but GOARCH is unset. Please set GOARCH to wasm", options.GOOS)
+			"src/runtime/asm_tinygowasm.S",
+			"src/internal/task/task_asyncify_wasm.S",
+		)
+		llvmos = "wasi"
 	default:
 		return nil, fmt.Errorf("unknown GOOS=%s", options.GOOS)
 	}
 
-	if spec.GC == "boehm" {
-		// Add this file only when needed. This fixes a build failure on
-		// Windows.
-		spec.ExtraFiles = append(spec.ExtraFiles, "src/runtime/gc_boehm.c")
-	}
-
 	// Target triples (which actually have four components, but are called
 	// triples for historical reasons) have the form:
 	//   arch-vendor-os-environment

compileopts/target_test.go

@@ -1,10 +1,8 @@
 package compileopts
 
 import (
-	"encoding/csv"
 	"errors"
 	"io/fs"
-	"os"
 	"reflect"
 	"testing"
 )
@@ -25,69 +23,6 @@ func TestLoadTarget(t *testing.T) {
 	}
 }
 
-func TestGetTargetSpecs_InheritableOnlyTargetsExcluded(t *testing.T) {
-	specs, err := GetTargetSpecs()
-	if err != nil {
-		t.Fatal("GetTargetSpecs failed:", err)
-	}
-
-	// Inheritable-only processor-level targets should not appear in the listing.
-	inheritableOnlyTargets := []string{"esp32", "esp32c3", "esp32s3", "esp8266", "rp2040", "rp2350", "rp2350b"}
-	for _, name := range inheritableOnlyTargets {
-		if _, ok := specs[name]; ok {
-			t.Errorf("inheritable-only target %q should not appear in GetTargetSpecs", name)
-		}
-	}
-
-	// Board targets that inherit from inheritable-only targets should still appear.
-	boardTargets := []string{"esp32-coreboard-v2", "pico"}
-	for _, name := range boardTargets {
-		if _, ok := specs[name]; !ok {
-			t.Errorf("board target %q should appear in GetTargetSpecs", name)
-		}
-	}
-}
-
-func TestLoadTarget_InheritableOnlyTargetStillLoadable(t *testing.T) {
-	// Inheritable-only targets should still be loadable directly (for building).
-	_, err := LoadTarget(&Options{Target: "esp32"})
-	if err != nil {
-		t.Errorf("LoadTarget should still load inheritable-only target esp32: %v", err)
-	}
-}
-
-func TestLoadPY32ConcreteTargets(t *testing.T) {
-	file, err := os.Open("../tools/gen-py32-targets/devices.csv")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer file.Close()
-
-	records, err := csv.NewReader(file).ReadAll()
-	if err != nil {
-		t.Fatal(err)
-	}
-	for _, record := range records[1:] {
-		part, core := record[0], record[2]
-		t.Run(part, func(t *testing.T) {
-			spec, err := LoadTarget(&Options{Target: part})
-			if err != nil {
-				t.Fatal(err)
-			}
-			if spec.LinkerScript == "" {
-				t.Error("concrete target has no linker script")
-			}
-			wantCPU := "cortex-m0plus"
-			if core == "m4" {
-				wantCPU = "cortex-m4"
-			}
-			if spec.CPU != wantCPU {
-				t.Errorf("CPU is %q, want %q", spec.CPU, wantCPU)
-			}
-		})
-	}
-}
-
 func TestOverrideProperties(t *testing.T) {
 	baseAutoStackSize := true
 	base := &TargetSpec{
@@ -146,52 +81,3 @@ func TestOverrideProperties(t *testing.T) {
 	}
 
 }
-
-func TestConfigLinkerFlavor(t *testing.T) {
-	tests := []struct {
-		name   string
-		target *TargetSpec
-		goos   string
-		want   string
-	}{
-		{
-			name:   "default gnu",
-			target: &TargetSpec{},
-			goos:   "linux",
-			want:   "gnu",
-		},
-		{
-			name:   "default coff",
-			target: &TargetSpec{},
-			goos:   "windows",
-			want:   "coff",
-		},
-		{
-			name:   "default darwin",
-			target: &TargetSpec{},
-			goos:   "darwin",
-			want:   "darwin",
-		},
-		{
-			name: "target override",
-			target: &TargetSpec{
-				LinkerFlavor: "coff",
-			},
-			goos: "linux",
-			want: "coff",
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			tc.target.GOOS = tc.goos
-			config := &Config{
-				Options: &Options{},
-				Target:  tc.target,
-			}
-			if got := config.LinkerFlavor(); got != tc.want {
-				t.Fatalf("LinkerFlavor() = %q, want %q", got, tc.want)
-			}
-		})
-	}
-}

compileopts/triple_llvm22.go

@@ -1,12 +0,0 @@
-//go:build llvm22
-
-package compileopts
-
-import "strings"
-
-// ClangTriple returns the target triple to pass to Clang's --target flag.
-// LLVM 22 deprecated the "wasm32-unknown-wasi" triple in favor of
-// "wasm32-unknown-wasip1", so we substitute it here to avoid warnings.
-func ClangTriple(triple string) string {
-	return strings.Replace(triple, "wasm32-unknown-wasi", "wasm32-unknown-wasip1", 1)
-}

compileopts/triple_pre22.go

@@ -1,9 +0,0 @@
-//go:build !llvm22
-
-package compileopts
-
-// ClangTriple returns the target triple to pass to Clang's --target flag.
-// For pre-LLVM 22, the triple is used as-is.
-func ClangTriple(triple string) string {
-	return triple
-}

compiler/alias.go

@@ -18,12 +18,11 @@ var stdlibAliases = map[string]string{
 	// crypto packages
 	"crypto/ed25519/internal/edwards25519/field.feMul": "crypto/ed25519/internal/edwards25519/field.feMulGeneric",
 	"crypto/internal/edwards25519/field.feSquare":      "crypto/ed25519/internal/edwards25519/field.feSquareGeneric",
-	"crypto/md5.block":           "crypto/md5.blockGeneric",
-	"crypto/sha1.block":          "crypto/sha1.blockGeneric",
-	"crypto/sha1.blockAMD64":     "crypto/sha1.blockGeneric",
-	"crypto/sha256.block":        "crypto/sha256.blockGeneric",
-	"crypto/sha512.blockAMD64":   "crypto/sha512.blockGeneric",
-	"internal/chacha8rand.block": "internal/chacha8rand.block_generic",
+	"crypto/md5.block":         "crypto/md5.blockGeneric",
+	"crypto/sha1.block":        "crypto/sha1.blockGeneric",
+	"crypto/sha1.blockAMD64":   "crypto/sha1.blockGeneric",
+	"crypto/sha256.block":      "crypto/sha256.blockGeneric",
+	"crypto/sha512.blockAMD64": "crypto/sha512.blockGeneric",
 
 	// AES
 	"crypto/aes.decryptBlockAsm": "crypto/aes.decryptBlock",

compiler/asserts.go

@@ -241,35 +241,22 @@ func (b *builder) createRuntimeAssert(assert llvm.Value, blockPrefix, assertFunc
 		}
 	}
 
-	faultBlock := b.getRuntimeAssertBlock(blockPrefix, assertFunc)
+	// Put the fault block at the end of the function and the next block at the
+	// current insert position.
+	faultBlock := b.ctx.AddBasicBlock(b.llvmFn, blockPrefix+".throw")
 	nextBlock := b.insertBasicBlock(blockPrefix + ".next")
-	b.currentBlockInfo.exit = nextBlock // adjust outgoing block for phi nodes
+	b.blockExits[b.currentBlock] = nextBlock // adjust outgoing block for phi nodes
 
 	// Now branch to the out-of-bounds or the regular block.
 	b.CreateCondBr(assert, faultBlock, nextBlock)
 
-	// Ok: assert didn't trigger so continue normally.
-	b.SetInsertPointAtEnd(nextBlock)
-}
-
-func (b *builder) getRuntimeAssertBlock(blockPrefix, assertFunc string) llvm.BasicBlock {
-	if b.runtimeAssertBlocks == nil {
-		b.runtimeAssertBlocks = make(map[string]llvm.BasicBlock)
-	}
-	if block := b.runtimeAssertBlocks[assertFunc]; !block.IsNil() {
-		return block
-	}
-	savedBlock := b.GetInsertBlock()
-	block := b.ctx.AddBasicBlock(b.llvmFn, blockPrefix+".throw")
-	b.runtimeAssertBlocks[assertFunc] = block
-	b.SetInsertPointAtEnd(block)
-	if b.hasDeferFrame() {
-		b.createFaultCheckpoint()
-	}
+	// Fail: the assert triggered so panic.
+	b.SetInsertPointAtEnd(faultBlock)
 	b.createRuntimeCall(assertFunc, nil, "")
 	b.CreateUnreachable()
-	b.SetInsertPointAtEnd(savedBlock)
-	return block
+
+	// Ok: assert didn't trigger so continue normally.
+	b.SetInsertPointAtEnd(nextBlock)
 }
 
 // extendInteger extends the value to at least targetType using a zero or sign

compiler/calls.go

@@ -32,12 +32,6 @@ const (
 	// Whether this is a full or partial Go parameter (int, slice, etc).
 	// The extra context parameter is not a Go parameter.
 	paramIsGoParam = 1 << iota
-
-	// Whether this is a readonly parameter (for example, a string pointer).
-	paramIsReadonly
-
-	// Whether this parameter is passed through backing storage.
-	paramIsIndirect
 )
 
 // createRuntimeCallCommon creates a runtime call. Use createRuntimeCall or
@@ -82,15 +76,7 @@ func (b *builder) createCall(fnType llvm.Type, fn llvm.Value, args []llvm.Value,
 		fragments := b.expandFormalParam(arg)
 		expanded = append(expanded, fragments...)
 	}
-	call := b.CreateCall(fnType, fn, expanded, name)
-	if !fn.IsAFunction().IsNil() {
-		if cc := fn.FunctionCallConv(); cc != llvm.CCallConv {
-			// Set a different calling convention if needed.
-			// This is needed for GetModuleHandleExA on Windows, for example.
-			call.SetInstructionCallConv(cc)
-		}
-	}
-	return call
+	return b.CreateCall(fnType, fn, expanded, name)
 }
 
 // createInvoke is like createCall but continues execution at the landing pad if
@@ -105,18 +91,6 @@ func (b *builder) createInvoke(fnType llvm.Type, fn llvm.Value, args []llvm.Valu
 // Expand an argument type to a list that can be used in a function call
 // parameter list.
 func (c *compilerContext) expandFormalParamType(t llvm.Type, name string, goType types.Type) []paramInfo {
-	if c.isIndirectAggregate(t) {
-		return []paramInfo{{
-			llvmType: c.dataPtrType,
-			name:     name,
-			elemSize: c.targetData.TypeAllocSize(t),
-			flags:    paramIsGoParam | paramIsReadonly | paramIsIndirect,
-		}}
-	}
-	return c.expandDirectFormalParamType(t, name, goType)
-}
-
-func (c *compilerContext) expandDirectFormalParamType(t llvm.Type, name string, goType types.Type) []paramInfo {
 	switch t.TypeKind() {
 	case llvm.StructTypeKind:
 		fieldInfos := c.flattenAggregateType(t, name, goType)
@@ -130,38 +104,6 @@ func (c *compilerContext) expandDirectFormalParamType(t llvm.Type, name string,
 	return []paramInfo{c.getParamInfo(t, name, goType)}
 }
 
-func (c *compilerContext) storedParamType(t llvm.Type, exported bool) llvm.Type {
-	if c.isIndirectParam(t, exported) {
-		return c.dataPtrType
-	}
-	return t
-}
-
-func (c *compilerContext) isIndirectParam(t llvm.Type, exported bool) bool {
-	return !exported && c.isIndirectAggregate(t)
-}
-
-func (b *builder) appendStoredValueTypes(valueTypes []llvm.Type, values []ssa.Value, exported bool) []llvm.Type {
-	for _, value := range values {
-		valueTypes = append(valueTypes, b.storedParamType(b.getLLVMType(value.Type()), exported))
-	}
-	return valueTypes
-}
-
-func (b *builder) appendStoredParamTypes(valueTypes []llvm.Type, params []*types.Var, exported bool) []llvm.Type {
-	for _, param := range params {
-		valueTypes = append(valueTypes, b.storedParamType(b.getLLVMType(param.Type()), exported))
-	}
-	return valueTypes
-}
-
-func (b *builder) prependIndirectResult(sig *types.Signature, exported bool, params []llvm.Value, name string) []llvm.Value {
-	if resultType, indirect := b.hasIndirectResult(sig); !exported && indirect {
-		return append([]llvm.Value{b.createIndirectStorage(resultType, name)}, params...)
-	}
-	return params
-}
-
 // expandFormalParamOffsets returns a list of offsets from the start of an
 // object of type t after it would have been split up by expandFormalParam. This
 // is useful for debug information, where it is necessary to know the offset
@@ -217,7 +159,6 @@ func (c *compilerContext) flattenAggregateType(t llvm.Type, name string, goType
 				continue
 			}
 			suffix := strconv.Itoa(i)
-			isString := false
 			if goType != nil {
 				// Try to come up with a good suffix for this struct field,
 				// depending on which Go type it's based on.
@@ -234,16 +175,12 @@ func (c *compilerContext) flattenAggregateType(t llvm.Type, name string, goType
 						suffix = []string{"r", "i"}[i]
 					case types.String:
 						suffix = []string{"data", "len"}[i]
-						isString = true
 					}
 				case *types.Signature:
 					suffix = []string{"context", "funcptr"}[i]
 				}
 			}
 			subInfos := c.flattenAggregateType(subfield, name+"."+suffix, extractSubfield(goType, i))
-			if isString {
-				subInfos[0].flags |= paramIsReadonly
-			}
 			paramInfos = append(paramInfos, subInfos...)
 		}
 		return paramInfos

compiler/channel.go

@@ -30,15 +30,17 @@ func (b *builder) createMakeChan(expr *ssa.MakeChan) llvm.Value {
 // actual channel send operation during goroutine lowering.
 func (b *builder) createChanSend(instr *ssa.Send) {
 	ch := b.getValue(instr.Chan, getPos(instr))
+	chanValue := b.getValue(instr.X, getPos(instr))
 
 	// store value-to-send
 	valueType := b.getLLVMType(instr.X.Type())
 	isZeroSize := b.targetData.TypeAllocSize(valueType) == 0
-	var storage valueStorage
+	var valueAlloca, valueAllocaSize llvm.Value
 	if isZeroSize {
-		storage.ptr = llvm.ConstNull(b.dataPtrType)
+		valueAlloca = llvm.ConstNull(b.dataPtrType)
 	} else {
-		storage = b.getValueStorage(instr.X, "chan.value")
+		valueAlloca, valueAllocaSize = b.createTemporaryAlloca(valueType, "chan.value")
+		b.CreateStore(chanValue, valueAlloca)
 	}
 
 	// Allocate buffer for the channel operation.
@@ -46,13 +48,15 @@ func (b *builder) createChanSend(instr *ssa.Send) {
 	channelOpAlloca, channelOpAllocaSize := b.createTemporaryAlloca(channelOp, "chan.op")
 
 	// Do the send.
-	b.createRuntimeInvoke("chanSend", []llvm.Value{ch, storage.ptr, channelOpAlloca}, "")
+	b.createRuntimeCall("chanSend", []llvm.Value{ch, valueAlloca, channelOpAlloca}, "")
 
 	// End the lifetime of the allocas.
 	// This also works around a bug in CoroSplit, at least in LLVM 8:
 	// https://bugs.llvm.org/show_bug.cgi?id=41742
 	b.emitLifetimeEnd(channelOpAlloca, channelOpAllocaSize)
-	b.endValueStorage(storage)
+	if !isZeroSize {
+		b.emitLifetimeEnd(valueAlloca, valueAllocaSize)
+	}
 }
 
 // createChanRecv emits a pseudo chan receive operation. It is lowered to the
@@ -62,22 +66,42 @@ func (b *builder) createChanRecv(unop *ssa.UnOp) llvm.Value {
 	ch := b.getValue(unop.X, getPos(unop))
 
 	// Allocate memory to receive into.
-	result := b.createRuntimeValueResult(valueType, unop.CommaOk, true, "chan")
+	isZeroSize := b.targetData.TypeAllocSize(valueType) == 0
+	var valueAlloca, valueAllocaSize llvm.Value
+	if isZeroSize {
+		valueAlloca = llvm.ConstNull(b.dataPtrType)
+	} else {
+		valueAlloca, valueAllocaSize = b.createTemporaryAlloca(valueType, "chan.value")
+	}
 
 	// Allocate buffer for the channel operation.
 	channelOp := b.getLLVMRuntimeType("channelOp")
 	channelOpAlloca, channelOpAllocaSize := b.createTemporaryAlloca(channelOp, "chan.op")
 
 	// Do the receive.
-	commaOk := b.createRuntimeCall("chanRecv", []llvm.Value{ch, result.valuePtr, channelOpAlloca}, "")
-	received := result.finish(b, commaOk, "chan.received")
+	commaOk := b.createRuntimeCall("chanRecv", []llvm.Value{ch, valueAlloca, channelOpAlloca}, "")
+	var received llvm.Value
+	if isZeroSize {
+		received = llvm.ConstNull(valueType)
+	} else {
+		received = b.CreateLoad(valueType, valueAlloca, "chan.received")
+		b.emitLifetimeEnd(valueAlloca, valueAllocaSize)
+	}
 	b.emitLifetimeEnd(channelOpAlloca, channelOpAllocaSize)
-	return received
+
+	if unop.CommaOk {
+		tuple := llvm.Undef(b.ctx.StructType([]llvm.Type{valueType, b.ctx.Int1Type()}, false))
+		tuple = b.CreateInsertValue(tuple, received, 0, "")
+		tuple = b.CreateInsertValue(tuple, commaOk, 1, "")
+		return tuple
+	} else {
+		return received
+	}
 }
 
 // createChanClose closes the given channel.
 func (b *builder) createChanClose(ch llvm.Value) {
-	b.createRuntimeInvoke("chanClose", []llvm.Value{ch}, "")
+	b.createRuntimeCall("chanClose", []llvm.Value{ch}, "")
 }
 
 // createSelect emits all IR necessary for a select statements. That's a
@@ -146,7 +170,9 @@ func (b *builder) createSelect(expr *ssa.Select) llvm.Value {
 		case types.SendOnly:
 			// Store this value in an alloca and put a pointer to this alloca
 			// in the send state.
-			alloca := b.getSelectSendStorage(state.Send)
+			sendValue := b.getValue(state.Send, state.Pos)
+			alloca := llvmutil.CreateEntryBlockAlloca(b.Builder, sendValue.Type(), "select.send.value")
+			b.CreateStore(sendValue, alloca)
 			selectState = b.CreateInsertValue(selectState, alloca, 1, "")
 		default:
 			panic("unreachable")
@@ -254,17 +280,7 @@ func (b *builder) getChanSelectResult(expr *ssa.Extract) llvm.Value {
 		// receive can proceed at a time) so we'll get that alloca, bitcast
 		// it to the correct type, and dereference it.
 		recvbuf := b.selectRecvBuf[expr.Tuple.(*ssa.Select)]
-		return b.loadFromStorage(recvbuf, expr.Type(), "select.received")
+		typ := b.getLLVMType(expr.Type())
+		return b.CreateLoad(typ, recvbuf, "")
 	}
 }
-
-func (b *builder) getSelectSendStorage(value ssa.Value) llvm.Value {
-	typ := b.getLLVMType(value.Type())
-	if b.isIndirectAggregate(typ) {
-		return b.getValuePointer(value)
-	}
-	llvmValue := b.getValue(value, getPos(value))
-	ptr := llvmutil.CreateEntryBlockAlloca(b.Builder, typ, "select.send.value")
-	b.CreateStore(llvmValue, ptr)
-	return ptr
-}

compiler/compiler.go

@@ -58,7 +58,6 @@ type Config struct {
 	MaxStackAlloc      uint64
 	NeedsStackObjects  bool
 	Debug              bool // Whether to emit debug information in the LLVM module.
-	Nobounds           bool // Whether to skip bounds checks
 	PanicStrategy      string
 }
 
@@ -90,10 +89,8 @@ type compilerContext struct {
 	astComments      map[string]*ast.CommentGroup
 	embedGlobals     map[string][]*loader.EmbedFile
 	pkg              *types.Package
-	loaderPkg        *loader.Package // current package being compiled (for AST access)
-	packageDir       string          // directory for this package
+	packageDir       string // directory for this package
 	runtimePkg       *types.Package
-	localTypeNames   typeutil.Map // *types.Named (synthetic local from generic instantiation) -> string
 }
 
 // newCompilerContext returns a new compiler context ready for use, most
@@ -154,14 +151,10 @@ type builder struct {
 	llvmFnType        llvm.Type
 	llvmFn            llvm.Value
 	info              functionInfo
-	locals            map[ssa.Value]llvm.Value // local variables
-	indirectValues    map[ssa.Value]llvm.Value
-	indirectReturn    llvm.Value
-	blockInfo         []blockInfo
+	locals            map[ssa.Value]llvm.Value            // local variables
+	blockEntries      map[*ssa.BasicBlock]llvm.BasicBlock // a *ssa.BasicBlock may be split up
+	blockExits        map[*ssa.BasicBlock]llvm.BasicBlock // these are the exit blocks
 	currentBlock      *ssa.BasicBlock
-	currentBlockInfo  *blockInfo
-	tarjanStack       []uint
-	tarjanIndex       uint
 	phis              []phiNode
 	deferPtr          llvm.Value
 	deferFrame        llvm.Value
@@ -171,7 +164,7 @@ type builder struct {
 	dilocals          map[*types.Var]llvm.Metadata
 	initInlinedAt     llvm.Metadata            // fake inlinedAt position
 	initPseudoFuncs   map[string]llvm.Metadata // fake "inlined" functions for proper init debug locations
-	allDeferFuncs     []any
+	allDeferFuncs     []interface{}
 	deferFuncs        map[*ssa.Function]int
 	deferInvokeFuncs  map[string]int
 	deferClosureFuncs map[*ssa.Function]int
@@ -180,9 +173,6 @@ type builder struct {
 	deferBuiltinFuncs map[ssa.Value]deferBuiltin
 	runDefersBlock    []llvm.BasicBlock
 	afterDefersBlock  []llvm.BasicBlock
-
-	runtimeAssertBlocks  map[string]llvm.BasicBlock
-	interfaceAssertBlock llvm.BasicBlock
 }
 
 func newBuilder(c *compilerContext, irbuilder llvm.Builder, f *ssa.Function) *builder {
@@ -195,24 +185,12 @@ func newBuilder(c *compilerContext, irbuilder llvm.Builder, f *ssa.Function) *bu
 		llvmFn:          fn,
 		info:            c.getFunctionInfo(f),
 		locals:          make(map[ssa.Value]llvm.Value),
-		indirectValues:  make(map[ssa.Value]llvm.Value),
 		dilocals:        make(map[*types.Var]llvm.Metadata),
+		blockEntries:    make(map[*ssa.BasicBlock]llvm.BasicBlock),
+		blockExits:      make(map[*ssa.BasicBlock]llvm.BasicBlock),
 	}
 }
 
-type blockInfo struct {
-	// entry is the LLVM basic block corresponding to the start of this *ssa.Block.
-	entry llvm.BasicBlock
-
-	// exit is the LLVM basic block corresponding to the end of this *ssa.Block.
-	// It will be different than entry if any of the block's instructions contain internal branches.
-	exit llvm.BasicBlock
-
-	// tarjan holds state for applying Tarjan's strongly connected components algorithm to the CFG.
-	// This is used by defer.go to determine whether to stack- or heap-allocate defer data.
-	tarjan tarjanNode
-}
-
 type deferBuiltin struct {
 	callName string
 	pos      token.Pos
@@ -296,23 +274,17 @@ func Sizes(machine llvm.TargetMachine) types.Sizes {
 }
 
 // CompilePackage compiles a single package to a LLVM module.
-//
-// The SSA package must already be built. When packages are compiled
-// concurrently, the entire SSA program must be built before compilation starts.
 func CompilePackage(moduleName string, pkg *loader.Package, ssaPkg *ssa.Package, machine llvm.TargetMachine, config *Config, dumpSSA bool) (llvm.Module, []error) {
 	c := newCompilerContext(moduleName, machine, config, dumpSSA)
 	defer c.dispose()
 	c.packageDir = pkg.OriginalDir()
 	c.embedGlobals = pkg.EmbedGlobals
 	c.pkg = pkg.Pkg
-	c.loaderPkg = pkg
 	c.runtimePkg = ssaPkg.Prog.ImportedPackage("runtime").Pkg
 	c.program = ssaPkg.Prog
 
-	// Assign names to function-local named types before compiling the
-	// package, so that types declared in different functions (or in
-	// different instantiations of a generic function) do not collide.
-	c.scanLocalTypes(ssaPkg)
+	// Convert AST to SSA.
+	ssaPkg.Build()
 
 	// Initialize debug information.
 	if c.Debug {
@@ -328,6 +300,9 @@ func CompilePackage(moduleName string, pkg *loader.Package, ssaPkg *ssa.Package,
 	// Load comments such as //go:extern on globals.
 	c.loadASTComments(pkg)
 
+	// Predeclare the runtime.alloc function, which is used by the wordpack
+	// functionality.
+	c.getFunction(c.program.ImportedPackage("runtime").Members["alloc"].(*ssa.Function))
 	if c.NeedsStackObjects {
 		// Predeclare trackPointer, which is used everywhere we use runtime.alloc.
 		c.getFunction(c.program.ImportedPackage("runtime").Members["trackPointer"].(*ssa.Function))
@@ -413,7 +388,7 @@ func (c *compilerContext) getLLVMType(goType types.Type) llvm.Type {
 // makeLLVMType creates a LLVM type for a Go type. Don't call this, use
 // getLLVMType instead.
 func (c *compilerContext) makeLLVMType(goType types.Type) llvm.Type {
-	switch typ := types.Unalias(goType).(type) {
+	switch typ := goType.(type) {
 	case *types.Array:
 		elemType := c.getLLVMType(typ.Elem())
 		return llvm.ArrayType(elemType, int(typ.Len()))
@@ -425,19 +400,19 @@ func (c *compilerContext) makeLLVMType(goType types.Type) llvm.Type {
 			return c.ctx.Int8Type()
 		case types.Int16, types.Uint16:
 			return c.ctx.Int16Type()
-		case types.Int32, types.Uint32, types.UntypedRune:
+		case types.Int32, types.Uint32:
 			return c.ctx.Int32Type()
-		case types.Int, types.Uint, types.UntypedInt:
+		case types.Int, types.Uint:
 			return c.intType
 		case types.Int64, types.Uint64:
 			return c.ctx.Int64Type()
 		case types.Float32:
 			return c.ctx.FloatType()
-		case types.Float64, types.UntypedFloat:
+		case types.Float64:
 			return c.ctx.DoubleType()
 		case types.Complex64:
 			return c.ctx.StructType([]llvm.Type{c.ctx.FloatType(), c.ctx.FloatType()}, false)
-		case types.Complex128, types.UntypedComplex:
+		case types.Complex128:
 			return c.ctx.StructType([]llvm.Type{c.ctx.DoubleType(), c.ctx.DoubleType()}, false)
 		case types.String, types.UntypedString:
 			return c.getLLVMRuntimeType("_string")
@@ -521,21 +496,6 @@ func (c *compilerContext) createDIType(typ types.Type) llvm.Metadata {
 	llvmType := c.getLLVMType(typ)
 	sizeInBytes := c.targetData.TypeAllocSize(llvmType)
 	switch typ := typ.(type) {
-	case *types.Alias:
-		// Implement types.Alias just like types.Named: by treating them like a
-		// C typedef.
-		temporaryMDNode := c.dibuilder.CreateReplaceableCompositeType(llvm.Metadata{}, llvm.DIReplaceableCompositeType{
-			Tag:         dwarf.TagTypedef,
-			SizeInBits:  sizeInBytes * 8,
-			AlignInBits: uint32(c.targetData.ABITypeAlignment(llvmType)) * 8,
-		})
-		c.ditypes[typ] = temporaryMDNode
-		md := c.dibuilder.CreateTypedef(llvm.DITypedef{
-			Type: c.getDIType(types.Unalias(typ)), // TODO: use typ.Rhs in Go 1.23
-			Name: typ.String(),
-		})
-		temporaryMDNode.ReplaceAllUsesWith(md)
-		return md
 	case *types.Array:
 		return c.dibuilder.CreateArrayType(llvm.DIArrayType{
 			SizeInBits:  sizeInBytes * 8,
@@ -873,9 +833,10 @@ func (c *compilerContext) createPackage(irbuilder llvm.Builder, pkg *ssa.Package
 			}
 			// Create the function definition.
 			b := newBuilder(c, irbuilder, member)
-			if ok := b.defineMathOp(); ok {
+			if _, ok := mathToLLVMMapping[member.RelString(nil)]; ok {
 				// The body of this function (if there is one) is ignored and
 				// replaced with a LLVM intrinsic call.
+				b.defineMathOp()
 				continue
 			}
 			if ok := b.defineMathBitsIntrinsic(); ok {
@@ -883,10 +844,6 @@ func (c *compilerContext) createPackage(irbuilder llvm.Builder, pkg *ssa.Package
 				// with a LLVM intrinsic.
 				continue
 			}
-			if ok := b.defineCryptoIntrinsic(); ok {
-				// Body of this function was replaced
-				continue
-			}
 			if member.Blocks == nil {
 				// Try to define this as an intrinsic function.
 				b.defineIntrinsicFunction()
@@ -901,11 +858,6 @@ func (c *compilerContext) createPackage(irbuilder llvm.Builder, pkg *ssa.Package
 				// Interfaces don't have concrete methods.
 				continue
 			}
-			if _, isalias := member.Type().(*types.Alias); isalias {
-				// Aliases don't need to be redefined, since they just refer to
-				// an already existing type whose methods will be defined.
-				continue
-			}
 
 			// Named type. We should make sure all methods are created.
 			// This includes both functions with pointer receivers and those
@@ -1247,29 +1199,14 @@ func (b *builder) createFunctionStart(intrinsic bool) {
 		// intrinsic (like an atomic operation). Create the entry block
 		// manually.
 		entryBlock = b.ctx.AddBasicBlock(b.llvmFn, "entry")
-		// Intrinsics may create internal branches (e.g. nil checks).
-		// They will attempt to access b.currentBlockInfo to update the exit block.
-		// Create some fake block info for them to access.
-		blockInfo := []blockInfo{
-			{
-				entry: entryBlock,
-				exit:  entryBlock,
-			},
-		}
-		b.blockInfo = blockInfo
-		b.currentBlockInfo = &blockInfo[0]
 	} else {
-		blocks := b.fn.Blocks
-		blockInfo := make([]blockInfo, len(blocks))
 		for _, block := range b.fn.DomPreorder() {
-			info := &blockInfo[block.Index]
 			llvmBlock := b.ctx.AddBasicBlock(b.llvmFn, block.Comment)
-			info.entry = llvmBlock
-			info.exit = llvmBlock
+			b.blockEntries[block] = llvmBlock
+			b.blockExits[block] = llvmBlock
 		}
-		b.blockInfo = blockInfo
 		// Normal functions have an entry block.
-		entryBlock = blockInfo[0].entry
+		entryBlock = b.blockEntries[b.fn.Blocks[0]]
 	}
 	b.SetInsertPointAtEnd(entryBlock)
 
@@ -1285,28 +1222,10 @@ func (b *builder) createFunctionStart(intrinsic bool) {
 
 	// Load function parameters
 	llvmParamIndex := 0
-	if _, indirectResult := b.hasIndirectResult(b.fn.Signature); indirectResult && !b.info.exported {
-		b.indirectReturn = b.llvmFn.Param(llvmParamIndex)
-		b.indirectReturn.SetName("return")
-		llvmParamIndex++
-	}
 	for _, param := range b.fn.Params {
 		llvmType := b.getLLVMType(param.Type())
-		if b.isIndirectParam(llvmType, b.info.exported) {
-			llvmParam := b.llvmFn.Param(llvmParamIndex)
-			llvmParam.SetName(param.Name())
-			b.indirectValues[param] = llvmParam
-			llvmParamIndex++
-			continue
-		}
-		var paramInfos []paramInfo
-		if b.info.exported {
-			paramInfos = b.expandDirectFormalParamType(llvmType, param.Name(), param.Type())
-		} else {
-			paramInfos = b.expandFormalParamType(llvmType, param.Name(), param.Type())
-		}
 		fields := make([]llvm.Value, 0, 1)
-		for _, info := range paramInfos {
+		for _, info := range b.expandFormalParamType(llvmType, param.Name(), param.Type()) {
 			param := b.llvmFn.Param(llvmParamIndex)
 			param.SetName(info.name)
 			fields = append(fields, param)
@@ -1383,9 +1302,8 @@ func (b *builder) createFunction() {
 		if b.DumpSSA {
 			fmt.Printf("%d: %s:\n", block.Index, block.Comment)
 		}
+		b.SetInsertPointAtEnd(b.blockEntries[block])
 		b.currentBlock = block
-		b.currentBlockInfo = &b.blockInfo[block.Index]
-		b.SetInsertPointAtEnd(b.currentBlockInfo.entry)
 		for _, instr := range block.Instrs {
 			if instr, ok := instr.(*ssa.DebugRef); ok {
 				if !b.Debug {
@@ -1444,8 +1362,8 @@ func (b *builder) createFunction() {
 	for _, phi := range b.phis {
 		block := phi.ssa.Block()
 		for i, edge := range phi.ssa.Edges {
-			llvmVal := b.getCallArgument(edge, false)
-			llvmBlock := b.blockInfo[block.Preds[i].Index].exit
+			llvmVal := b.getValue(edge, getPos(phi.ssa))
+			llvmBlock := b.blockExits[block.Preds[i]]
 			phi.llvm.AddIncoming([]llvm.Value{llvmVal}, []llvm.BasicBlock{llvmBlock})
 		}
 	}
@@ -1453,9 +1371,6 @@ func (b *builder) createFunction() {
 	if b.NeedsStackObjects {
 		// Track phi nodes.
 		for _, phi := range b.phis {
-			if b.isOversizedAggregate(phi.ssa.Type()) {
-				continue
-			}
 			insertPoint := llvm.NextInstruction(phi.llvm)
 			for !insertPoint.IsAPHINode().IsNil() {
 				insertPoint = llvm.NextInstruction(insertPoint)
@@ -1547,7 +1462,10 @@ func (b *builder) createInstruction(instr ssa.Instruction) {
 			b.diagnostics = append(b.diagnostics, err)
 			b.locals[instr] = llvm.Undef(b.getLLVMType(instr.Type()))
 		} else {
-			b.setValue(instr, value)
+			b.locals[instr] = value
+			if len(*instr.Referrers()) != 0 && b.NeedsStackObjects {
+				b.trackExpr(instr, value)
+			}
 		}
 	case *ssa.DebugRef:
 		// ignore
@@ -1559,16 +1477,18 @@ func (b *builder) createInstruction(instr ssa.Instruction) {
 	case *ssa.If:
 		cond := b.getValue(instr.Cond, getPos(instr))
 		block := instr.Block()
-		blockThen := b.blockInfo[block.Succs[0].Index].entry
-		blockElse := b.blockInfo[block.Succs[1].Index].entry
+		blockThen := b.blockEntries[block.Succs[0]]
+		blockElse := b.blockEntries[block.Succs[1]]
 		b.CreateCondBr(cond, blockThen, blockElse)
 	case *ssa.Jump:
-		blockJump := b.blockInfo[instr.Block().Succs[0].Index].entry
+		blockJump := b.blockEntries[instr.Block().Succs[0]]
 		b.CreateBr(blockJump)
 	case *ssa.MapUpdate:
 		m := b.getValue(instr.Map, getPos(instr))
+		key := b.getValue(instr.Key, getPos(instr))
+		value := b.getValue(instr.Value, getPos(instr))
 		mapType := instr.Map.Type().Underlying().(*types.Map)
-		b.createMapUpdate(mapType.Key(), m, instr.Key, instr.Value, instr.Pos())
+		b.createMapUpdate(mapType.Key(), m, key, value, instr.Pos())
 	case *ssa.Panic:
 		value := b.getValue(instr.X, getPos(instr))
 		b.createRuntimeInvoke("_panic", []llvm.Value{value}, "")
@@ -1577,7 +1497,19 @@ func (b *builder) createInstruction(instr ssa.Instruction) {
 		if b.hasDeferFrame() {
 			b.createRuntimeCall("destroyDeferFrame", []llvm.Value{b.deferFrame}, "")
 		}
-		b.createReturn(instr.Results, getPos(instr))
+		if len(instr.Results) == 0 {
+			b.CreateRetVoid()
+		} else if len(instr.Results) == 1 {
+			b.CreateRet(b.getValue(instr.Results[0], getPos(instr)))
+		} else {
+			// Multiple return values. Put them all in a struct.
+			retVal := llvm.ConstNull(b.llvmFn.GlobalValueType().ReturnType())
+			for i, result := range instr.Results {
+				val := b.getValue(result, getPos(instr))
+				retVal = b.CreateInsertValue(retVal, val, i, "")
+			}
+			b.CreateRet(retVal)
+		}
 	case *ssa.RunDefers:
 		// Note where we're going to put the rundefers block
 		run := b.insertBasicBlock("rundefers.block")
@@ -1591,246 +1523,18 @@ func (b *builder) createInstruction(instr ssa.Instruction) {
 		b.createChanSend(instr)
 	case *ssa.Store:
 		llvmAddr := b.getValue(instr.Addr, getPos(instr))
+		llvmVal := b.getValue(instr.Val, getPos(instr))
 		b.createNilCheck(instr.Addr, llvmAddr, "store")
-		llvmType := b.getLLVMType(instr.Val.Type())
-		if b.targetData.TypeAllocSize(llvmType) == 0 {
+		if b.targetData.TypeAllocSize(llvmVal.Type()) == 0 {
 			// nothing to store
 			return
 		}
-		b.storeValue(llvmAddr, instr.Val)
+		b.CreateStore(llvmVal, llvmAddr)
 	default:
 		b.addError(instr.Pos(), "unknown instruction: "+instr.String())
 	}
 }
 
-func (b *builder) setValue(value ssa.Value, llvmValue llvm.Value) {
-	if b.isAggregateValue(value.Type()) && !llvmValue.IsNil() && llvmValue.Type().TypeKind() == llvm.PointerTypeKind {
-		b.indirectValues[value] = llvmValue
-		return
-	}
-	b.locals[value] = llvmValue
-	if len(*value.Referrers()) != 0 && b.NeedsStackObjects {
-		b.trackExpr(value, llvmValue)
-	}
-}
-
-func (b *builder) createReturn(results []ssa.Value, pos token.Pos) {
-	if len(results) == 0 {
-		b.CreateRetVoid()
-	} else if !b.indirectReturn.IsNil() {
-		if len(results) == 1 {
-			b.storeValue(b.indirectReturn, results[0])
-		} else {
-			returnType := b.getLLVMResultType(b.fn.Signature)
-			for i, result := range results {
-				fieldPtr := b.CreateStructGEP(returnType, b.indirectReturn, i, "")
-				b.storeValue(fieldPtr, result)
-			}
-		}
-		b.CreateRetVoid()
-	} else if len(results) == 1 {
-		b.CreateRet(b.getValue(results[0], pos))
-	} else {
-		result := llvm.ConstNull(b.llvmFn.GlobalValueType().ReturnType())
-		for i, value := range results {
-			result = b.CreateInsertValue(result, b.getValue(value, pos), i, "")
-		}
-		b.CreateRet(result)
-	}
-}
-
-func (b *builder) isOversizedAggregate(typ types.Type) bool {
-	if !b.isAggregateValue(typ) {
-		return false
-	}
-	return b.isIndirectAggregate(b.getLLVMType(typ))
-}
-
-func (b *builder) isAggregateValue(typ types.Type) bool {
-	if tuple, ok := typ.(*types.Tuple); ok {
-		for i := 0; i < tuple.Len(); i++ {
-			if !isLLVMValueType(tuple.At(i).Type()) {
-				return false
-			}
-		}
-	} else {
-		switch typ.Underlying().(type) {
-		case *types.Array, *types.Struct:
-		default:
-			return false
-		}
-		if !isLLVMValueType(typ) {
-			return false
-		}
-	}
-	return true
-}
-
-func (b *builder) getValuePointer(value ssa.Value) llvm.Value {
-	if ptr, ok := b.indirectValues[value]; ok {
-		return ptr
-	}
-	llvmType := b.getLLVMType(value.Type())
-	ptr := b.createIndirectStorage(llvmType, value.Name())
-	b.storeValue(ptr, value)
-	return ptr
-}
-
-func (b *builder) getCallArgument(value ssa.Value, exported bool) llvm.Value {
-	paramType := b.getLLVMType(value.Type())
-	if b.isIndirectParam(paramType, exported) {
-		return b.getValuePointer(value)
-	}
-	return b.getValue(value, getPos(value))
-}
-
-func (b *builder) createIndirectStorage(typ llvm.Type, name string) llvm.Value {
-	// Use runtime.alloc here so storage that escapes remains valid. The
-	// allocation optimizer moves bounded non-escaping storage to the stack.
-	size := llvm.ConstInt(b.uintptrType, b.targetData.TypeAllocSize(typ), false)
-	layout := b.createObjectLayout(typ, b.fn.Pos())
-	ptr := b.createAlloc(size, layout, b.targetData.ABITypeAlignment(typ), name)
-	if b.NeedsStackObjects {
-		b.trackPointer(ptr)
-	}
-	return ptr
-}
-
-func (b *builder) copyIndirectAggregate(dst, src llvm.Value, typ llvm.Type) {
-	size := llvm.ConstInt(b.uintptrType, b.targetData.TypeAllocSize(typ), false)
-	b.createMemCopy("memcpy", dst, src, size)
-}
-
-func (b *builder) storeValue(dst llvm.Value, value ssa.Value) {
-	typ := b.getLLVMType(value.Type())
-	if src, ok := b.indirectValues[value]; ok {
-		b.copyIndirectAggregate(dst, src, typ)
-	} else {
-		b.CreateStore(b.getValue(value, getPos(value)), dst)
-	}
-}
-
-func (b *builder) copyToIndirectStorage(src llvm.Value, typ llvm.Type, name string) llvm.Value {
-	dst := b.createIndirectStorage(typ, name)
-	b.copyIndirectAggregate(dst, src, typ)
-	return dst
-}
-
-func (b *builder) loadFromStorage(ptr llvm.Value, typ types.Type, name string) llvm.Value {
-	llvmType := b.getLLVMType(typ)
-	if b.isIndirectAggregate(llvmType) {
-		return b.copyToIndirectStorage(ptr, llvmType, name)
-	}
-	return b.CreateLoad(llvmType, ptr, name)
-}
-
-func (b *builder) getValueField(value ssa.Value, index int, resultType types.Type, name string) (llvm.Value, bool) {
-	if !b.isAggregateValue(value.Type()) {
-		return llvm.Value{}, false
-	}
-	valueType := b.getLLVMType(value.Type())
-	if _, indirect := b.indirectValues[value]; !indirect && !b.isIndirectAggregate(valueType) {
-		return llvm.Value{}, false
-	}
-	fieldPtr := b.CreateStructGEP(valueType, b.getValuePointer(value), index, "")
-	return b.loadFromStorage(fieldPtr, resultType, name), true
-}
-
-func (b *builder) zeroIndirectStorage(ptr llvm.Value, typ llvm.Type) {
-	memset := b.getMemsetFunc()
-	b.createCall(memset.GlobalValueType(), memset, []llvm.Value{
-		ptr,
-		llvm.ConstInt(b.ctx.Int8Type(), 0, false),
-		llvm.ConstInt(b.uintptrType, b.targetData.TypeAllocSize(typ), false),
-		llvm.ConstInt(b.ctx.Int1Type(), 0, false),
-	}, "")
-}
-
-type valueStorage struct {
-	ptr, size llvm.Value
-	temporary bool
-}
-
-func (b *builder) getValueStorage(value ssa.Value, name string) valueStorage {
-	typ := b.getLLVMType(value.Type())
-	if b.isIndirectAggregate(typ) {
-		return valueStorage{ptr: b.getValuePointer(value)}
-	}
-	ptr, size := b.createTemporaryAlloca(typ, name)
-	b.storeValue(ptr, value)
-	return valueStorage{ptr: ptr, size: size, temporary: true}
-}
-
-func (b *builder) endValueStorage(storage valueStorage) {
-	if storage.temporary {
-		b.emitLifetimeEnd(storage.ptr, storage.size)
-	}
-}
-
-type runtimeValueResult struct {
-	valueType  llvm.Type
-	resultType llvm.Type
-	result     llvm.Value
-	valuePtr   llvm.Value
-	valueSize  llvm.Value
-	temporary  bool
-	zero       bool
-	commaOk    bool
-}
-
-func (b *builder) createRuntimeValueResult(valueType llvm.Type, commaOk, zeroAsNull bool, name string) runtimeValueResult {
-	result := runtimeValueResult{
-		valueType:  valueType,
-		resultType: valueType,
-		valueSize:  llvm.ConstInt(b.uintptrType, b.targetData.TypeAllocSize(valueType), false),
-		commaOk:    commaOk,
-	}
-	if commaOk {
-		result.resultType = b.ctx.StructType([]llvm.Type{valueType, b.ctx.Int1Type()}, false)
-	}
-	if b.isIndirectAggregate(result.resultType) {
-		result.result = b.createIndirectStorage(result.resultType, name+".result")
-		result.valuePtr = result.result
-		if commaOk {
-			result.valuePtr = b.CreateStructGEP(result.resultType, result.result, 0, "")
-		}
-		return result
-	}
-	if zeroAsNull && b.targetData.TypeAllocSize(valueType) == 0 {
-		result.valuePtr = llvm.ConstNull(b.dataPtrType)
-		result.zero = true
-		return result
-	}
-	result.valuePtr, result.valueSize = b.createTemporaryAlloca(valueType, name+".value")
-	result.temporary = true
-	return result
-}
-
-func (r runtimeValueResult) finish(b *builder, commaOk llvm.Value, name string) llvm.Value {
-	if !r.result.IsNil() {
-		if r.commaOk {
-			b.CreateStore(commaOk, b.CreateStructGEP(r.resultType, r.result, 1, ""))
-		}
-		return r.result
-	}
-
-	var value llvm.Value
-	if r.zero {
-		value = llvm.ConstNull(r.valueType)
-	} else {
-		value = b.CreateLoad(r.valueType, r.valuePtr, name)
-	}
-	if r.temporary {
-		b.emitLifetimeEnd(r.valuePtr, r.valueSize)
-	}
-	if !r.commaOk {
-		return value
-	}
-	result := llvm.Undef(r.resultType)
-	result = b.CreateInsertValue(result, value, 0, "")
-	return b.CreateInsertValue(result, commaOk, 1, "")
-}
-
 // createBuiltin lowers a builtin Go function (append, close, delete, etc.) to
 // LLVM IR. It uses runtime calls for some builtins.
 func (b *builder) createBuiltin(argTypes []types.Type, argValues []llvm.Value, callName string, pos token.Pos) (llvm.Value, error) {
@@ -1845,8 +1549,7 @@ func (b *builder) createBuiltin(argTypes []types.Type, argValues []llvm.Value, c
 		elemsLen := b.CreateExtractValue(elems, 1, "append.elemsLen")
 		elemType := b.getLLVMType(argTypes[0].Underlying().(*types.Slice).Elem())
 		elemSize := llvm.ConstInt(b.uintptrType, b.targetData.TypeAllocSize(elemType), false)
-		elemLayout := b.createObjectLayout(elemType, pos)
-		result := b.createRuntimeCall("sliceAppend", []llvm.Value{srcBuf, elemsBuf, srcLen, srcCap, elemsLen, elemSize, elemLayout}, "append.new")
+		result := b.createRuntimeCall("sliceAppend", []llvm.Value{srcBuf, elemsBuf, srcLen, srcCap, elemsLen, elemSize}, "append.new")
 		newPtr := b.CreateExtractValue(result, 0, "append.newPtr")
 		newLen := b.CreateExtractValue(result, 1, "append.newLen")
 		newCap := b.CreateExtractValue(result, 2, "append.newCap")
@@ -1928,41 +1631,13 @@ func (b *builder) createBuiltin(argTypes []types.Type, argValues []llvm.Value, c
 	case "copy":
 		dst := argValues[0]
 		src := argValues[1]
-		// Fetch the lengths.
 		dstLen := b.CreateExtractValue(dst, 1, "copy.dstLen")
 		srcLen := b.CreateExtractValue(src, 1, "copy.srcLen")
-		// Find the minimum of the lengths.
-		minFuncName := "llvm.umin.i" + strconv.Itoa(b.uintptrType.IntTypeWidth())
-		minFunc := b.mod.NamedFunction(minFuncName)
-		if minFunc.IsNil() {
-			fnType := llvm.FunctionType(b.uintptrType, []llvm.Type{b.uintptrType, b.uintptrType}, false)
-			minFunc = llvm.AddFunction(b.mod, minFuncName, fnType)
-		}
-		minLen := b.CreateCall(minFunc.GlobalValueType(), minFunc, []llvm.Value{dstLen, srcLen}, "copy.n")
-		// Multiply the length by the element size.
+		dstBuf := b.CreateExtractValue(dst, 0, "copy.dstArray")
+		srcBuf := b.CreateExtractValue(src, 0, "copy.srcArray")
 		elemType := b.getLLVMType(argTypes[0].Underlying().(*types.Slice).Elem())
 		elemSize := llvm.ConstInt(b.uintptrType, b.targetData.TypeAllocSize(elemType), false)
-		// NOTE: This is also NSW when uintptr is int, but we can only choose one through the C API?
-		size := b.CreateNUWMul(minLen, elemSize, "copy.size")
-		// Fetch the pointers.
-		dstBuf := b.CreateExtractValue(dst, 0, "copy.dstPtr")
-		srcBuf := b.CreateExtractValue(src, 0, "copy.srcPtr")
-		// Create a memcpy.
-		call := b.createMemCopy("memmove", dstBuf, srcBuf, size)
-		align := b.targetData.ABITypeAlignment(elemType)
-		if align > 1 {
-			// Apply the type's alignment to the arguments.
-			// LLVM sometimes turns constant-length moves into loads and stores.
-			// It may use this alignment for the created loads and stores.
-			alignAttr := b.ctx.CreateEnumAttribute(llvm.AttributeKindID("align"), uint64(align))
-			call.AddCallSiteAttribute(1, alignAttr)
-			call.AddCallSiteAttribute(2, alignAttr)
-		}
-		// Extend and return the copied length.
-		if b.targetData.TypeAllocSize(minLen.Type()) < b.targetData.TypeAllocSize(b.intType) {
-			minLen = b.CreateZExt(minLen, b.intType, "copy.n.zext")
-		}
-		return minLen, nil
+		return b.createRuntimeCall("sliceCopy", []llvm.Value{dstBuf, srcBuf, dstLen, srcLen, elemSize}, "copy.n"), nil
 	case "delete":
 		m := argValues[0]
 		key := argValues[1]
@@ -1990,66 +1665,20 @@ func (b *builder) createBuiltin(argTypes []types.Type, argValues []llvm.Value, c
 		return llvmLen, nil
 	case "min", "max":
 		// min and max builtins, added in Go 1.21.
-		// Find the corresponding intrinsic name.
-		ty := argTypes[0].Underlying().(*types.Basic)
-		llvmType := b.getLLVMType(ty)
-		info := ty.Info()
-		var prefix, delimeter, typeName string
-		if info&types.IsInteger != 0 {
-			// This is an integer value.
-			// Use the LLVM int min/max intrinsics.
-			prefix = "llvm.s"
-			if info&types.IsUnsigned != 0 {
-				prefix = "llvm.u"
-			}
-			delimeter = ".i"
-			typeName = strconv.Itoa(llvmType.IntTypeWidth())
-		} else {
-			switch ty.Kind() {
-			case types.String:
-				// Strings do not have an equivalent intrinsic.
-				// Implement with compares and selects.
-				tok := token.LSS
-				if callName == "max" {
-					tok = token.GTR
-				}
-				result := argValues[0]
-				typ := argTypes[0]
-				for _, arg := range argValues[1:] {
-					cmp, err := b.createBinOp(tok, typ, typ, result, arg, pos)
-					if err != nil {
-						return result, err
-					}
-					result = b.CreateSelect(cmp, result, arg, "")
-				}
-				return result, nil
-			case types.Float32:
-				typeName = "f32"
-			case types.Float64:
-				typeName = "f64"
-			default:
-				return llvm.Value{}, b.makeError(pos, "todo: min/max: unknown type")
-			}
-			// There are a few edge cases with floating point min/max:
-			// min(-0.0, +0.0) = -0.0
-			// min(NaN, number) = NaN
-			// The llvm.minimum.*/llvm.maximum.* intrinsics match this behavior.
-			// Neither Go nor LLVM defines the bit representation of resulting NaNs.
-			prefix = "llvm."
-			delimeter = "imum."
+		// We can simply reuse the existing binop comparison code, which has all
+		// the edge cases figured out already.
+		tok := token.LSS
+		if callName == "max" {
+			tok = token.GTR
 		}
-		intrinsicName := prefix + callName + delimeter + typeName
-		// Find or create the intrinsic.
-		llvmFn := b.mod.NamedFunction(intrinsicName)
-		if llvmFn.IsNil() {
-			fnType := llvm.FunctionType(llvmType, []llvm.Type{llvmType, llvmType}, false)
-			llvmFn = llvm.AddFunction(b.mod, intrinsicName, fnType)
-		}
-		// Call the intrinsic repeatedly to merge the arguments.
-		callType := llvmFn.GlobalValueType()
 		result := argValues[0]
+		typ := argTypes[0]
 		for _, arg := range argValues[1:] {
-			result = b.CreateCall(callType, llvmFn, []llvm.Value{result, arg}, "")
+			cmp, err := b.createBinOp(tok, typ, typ, result, arg, pos)
+			if err != nil {
+				return result, err
+			}
+			result = b.CreateSelect(cmp, result, arg, "")
 		}
 		return result, nil
 	case "panic":
@@ -2130,12 +1759,6 @@ func (b *builder) createBuiltin(argTypes []types.Type, argValues []llvm.Value, c
 			// not of the current function.
 			useParentFrame = 1
 		}
-		// Prevent inlining of functions that call recover(), matching the
-		// Go compiler's behavior. If this function were inlined into a
-		// deferred function, recover() would incorrectly succeed because
-		// the inlined code runs in the deferred function's context.
-		noinline := b.ctx.CreateEnumAttribute(llvm.AttributeKindID("noinline"), 0)
-		b.llvmFn.AddFunctionAttr(noinline)
 		return b.createRuntimeCall("_recover", []llvm.Value{llvm.ConstInt(b.ctx.Int1Type(), useParentFrame, false)}, ""), nil
 	case "ssa:wrapnilchk":
 		// TODO: do an actual nil check?
@@ -2212,11 +1835,19 @@ func (b *builder) createBuiltin(argTypes []types.Type, argValues []llvm.Value, c
 //
 // This is also where compiler intrinsics are implemented.
 func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error) {
-	// See if this is an intrinsic function that is handled specially.
+	var params []llvm.Value
+	for _, param := range instr.Args {
+		params = append(params, b.getValue(param, getPos(instr)))
+	}
+
+	// Try to call the function directly for trivially static calls.
+	var callee, context llvm.Value
+	var calleeType llvm.Type
+	exported := false
 	if fn := instr.StaticCallee(); fn != nil {
 		// Direct function call, either to a named or anonymous (directly
 		// applied) function call. If it is anonymous, it may be a closure.
-		name := b.getFunctionInfo(fn).linkName
+		name := fn.RelString(nil)
 		switch {
 		case name == "device.Asm" || name == "device/arm.Asm" || name == "device/arm64.Asm" || name == "device/avr.Asm" || name == "device/riscv.Asm":
 			return b.createInlineAsm(instr.Args)
@@ -2228,14 +1859,10 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 			return b.emitSV64Call(instr.Args, getPos(instr))
 		case strings.HasPrefix(name, "(device/riscv.CSR)."):
 			return b.emitCSROperation(instr)
-		case (strings.HasPrefix(name, "syscall.Syscall") || strings.HasPrefix(name, "syscall.RawSyscall") || strings.HasPrefix(name, "golang.org/x/sys/unix.Syscall") || strings.HasPrefix(name, "golang.org/x/sys/unix.RawSyscall")) && name != "syscall.SyscallN":
+		case strings.HasPrefix(name, "syscall.Syscall") || strings.HasPrefix(name, "syscall.RawSyscall") || strings.HasPrefix(name, "golang.org/x/sys/unix.Syscall") || strings.HasPrefix(name, "golang.org/x/sys/unix.RawSyscall"):
 			if b.GOOS != "darwin" {
 				return b.createSyscall(instr)
 			}
-		case name == "syscall.syscalln":
-			if b.GOOS == "windows" {
-				return b.createSyscalln(instr)
-			}
 		case strings.HasPrefix(name, "syscall.rawSyscallNoError") || strings.HasPrefix(name, "golang.org/x/sys/unix.RawSyscallNoError"):
 			return b.createRawSyscallNoError(instr)
 		case name == "runtime.supportsRecover":
@@ -2252,25 +1879,13 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 			return llvm.ConstInt(b.ctx.Int8Type(), panicStrategy, false), nil
 		case name == "runtime/interrupt.New":
 			return b.createInterruptGlobal(instr)
-		case name == "runtime.exportedFuncPtr":
-			_, ptr := b.getFunction(instr.Args[0].(*ssa.Function))
-			return b.CreatePtrToInt(ptr, b.uintptrType, ""), nil
-		case name == "(*runtime/interrupt.Checkpoint).Save":
-			return b.createInterruptCheckpoint(instr.Args[0]), nil
 		case name == "internal/abi.FuncPCABI0":
 			retval := b.createDarwinFuncPCABI0Call(instr)
 			if !retval.IsNil() {
 				return retval, nil
 			}
 		}
-	}
 
-	// Try to call the function directly for trivially static calls.
-	var callee, context llvm.Value
-	var calleeType llvm.Type
-	var invokeTypecode, invokeReceiver llvm.Value
-	exported := false
-	if fn := instr.StaticCallee(); fn != nil {
 		calleeType, callee = b.getFunction(fn)
 		info := b.getFunctionInfo(fn)
 		if callee.IsNil() {
@@ -2298,18 +1913,19 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 		exported = info.exported
 	} else if call, ok := instr.Value.(*ssa.Builtin); ok {
 		// Builtin function (append, close, delete, etc.).)
-		var params []llvm.Value
 		var argTypes []types.Type
 		for _, arg := range instr.Args {
 			argTypes = append(argTypes, arg.Type())
-			params = append(params, b.getValue(arg, getPos(instr)))
 		}
 		return b.createBuiltin(argTypes, params, call.Name(), instr.Pos())
 	} else if instr.IsInvoke() {
 		// Interface method call (aka invoke call).
 		itf := b.getValue(instr.Value, getPos(instr)) // interface value (runtime._interface)
-		invokeTypecode = b.CreateExtractValue(itf, 0, "invoke.func.typecode")
-		invokeReceiver = b.CreateExtractValue(itf, 1, "invoke.func.value")
+		typecode := b.CreateExtractValue(itf, 0, "invoke.func.typecode")
+		value := b.CreateExtractValue(itf, 1, "invoke.func.value") // receiver
+		// Prefix the params with receiver value and suffix with typecode.
+		params = append([]llvm.Value{value}, params...)
+		params = append(params, typecode)
 		callee = b.getInvokeFunction(instr)
 		calleeType = callee.GlobalValueType()
 		context = llvm.Undef(b.dataPtrType)
@@ -2323,23 +1939,7 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 		b.createNilCheck(instr.Value, callee, "fpcall")
 	}
 
-	var params []llvm.Value
-	for _, param := range instr.Args {
-		params = append(params, b.getCallArgument(param, exported))
-	}
-	if instr.IsInvoke() {
-		params = append([]llvm.Value{invokeReceiver}, params...)
-		params = append(params, invokeTypecode)
-	}
-
 	if !exported {
-		if resultType, indirectResult := b.hasIndirectResult(instr.Signature()); indirectResult {
-			result := b.createIndirectStorage(resultType, "call.result")
-			params = append([]llvm.Value{result}, params...)
-			params = append(params, context)
-			b.createInvoke(calleeType, callee, params, "")
-			return result, nil
-		}
 		// This function takes a context parameter.
 		// Add it to the end of the parameter list.
 		params = append(params, context)
@@ -2378,9 +1978,6 @@ func (b *builder) getValue(expr ssa.Value, pos token.Pos) llvm.Value {
 		return value
 	default:
 		// other (local) SSA value
-		if value, ok := b.indirectValues[expr]; ok {
-			return b.CreateLoad(b.getLLVMType(expr.Type()), value, "")
-		}
 		if value, ok := b.locals[expr]; ok {
 			return value
 		} else {
@@ -2405,10 +2002,13 @@ func (c *compilerContext) maxSliceSize(elementType llvm.Type) uint64 {
 	if elementSize == 0 {
 		elementSize = 1
 	}
-	maxSize := min(
-		// len(slice) is an int. Make sure the length remains small enough to fit in
-		// an int.
-		maxPointerValue/elementSize, maxIntegerValue)
+	maxSize := maxPointerValue / elementSize
+
+	// len(slice) is an int. Make sure the length remains small enough to fit in
+	// an int.
+	if maxSize > maxIntegerValue {
+		maxSize = maxIntegerValue
+	}
 
 	return maxSize
 }
@@ -2435,8 +2035,9 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 			}
 			sizeValue := llvm.ConstInt(b.uintptrType, size, false)
 			layoutValue := b.createObjectLayout(typ, expr.Pos())
+			buf := b.createRuntimeCall("alloc", []llvm.Value{sizeValue, layoutValue}, expr.Comment)
 			align := b.targetData.ABITypeAlignment(typ)
-			buf := b.createAlloc(sizeValue, layoutValue, align, expr.Comment)
+			buf.AddCallSiteAttribute(0, b.ctx.CreateEnumAttribute(llvm.AttributeKindID("align"), uint64(align)))
 			return buf, nil
 		} else {
 			buf := llvmutil.CreateEntryBlockAlloca(b.Builder, typ, expr.Comment)
@@ -2463,15 +2064,8 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 		// This instruction changes the type, but the underlying value remains
 		// the same. This is often a no-op, but sometimes we have to change the
 		// LLVM type as well.
-		llvmType := b.getLLVMType(expr.Type())
-		if b.isIndirectAggregate(llvmType) {
-			sourceType := b.getLLVMType(expr.X.Type())
-			if !b.isIndirectAggregate(sourceType) || b.targetData.TypeAllocSize(sourceType) != b.targetData.TypeAllocSize(llvmType) {
-				return llvm.Value{}, errors.New("todo: indirect aggregate ChangeType with different layout")
-			}
-			return b.getValuePointer(expr.X), nil
-		}
 		x := b.getValue(expr.X, getPos(expr))
+		llvmType := b.getLLVMType(expr.Type())
 		if x.Type() == llvmType {
 			// Different Go type but same LLVM type (for example, named int).
 			// This is the common case.
@@ -2501,15 +2095,9 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 		if _, ok := expr.Tuple.(*ssa.Select); ok {
 			return b.getChanSelectResult(expr), nil
 		}
-		if value, ok := b.getValueField(expr.Tuple, expr.Index, expr.Type(), expr.Name()); ok {
-			return value, nil
-		}
 		value := b.getValue(expr.Tuple, getPos(expr))
 		return b.CreateExtractValue(value, expr.Index, ""), nil
 	case *ssa.Field:
-		if value, ok := b.getValueField(expr.X, expr.Field, expr.Type(), expr.Name()); ok {
-			return value, nil
-		}
 		value := b.getValue(expr.X, getPos(expr))
 		result := b.CreateExtractValue(value, expr.Field, "")
 		return result, nil
@@ -2532,11 +2120,11 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 	case *ssa.Global:
 		panic("global is not an expression")
 	case *ssa.Index:
+		collection := b.getValue(expr.X, getPos(expr))
 		index := b.getValue(expr.Index, getPos(expr))
 
 		switch xType := expr.X.Type().Underlying().(type) {
 		case *types.Basic: // extract byte from string
-			collection := b.getValue(expr.X, getPos(expr))
 			// Value type must be a string, which is a basic type.
 			if xType.Info()&types.IsString == 0 {
 				panic("lookup on non-string?")
@@ -2570,12 +2158,13 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 
 			// Can't load directly from array (as index is non-constant), so
 			// have to do it using an alloca+gep+load.
-			arrayType := b.getLLVMType(expr.X.Type())
-			storage := b.getValueStorage(expr.X, "index.alloca")
+			arrayType := collection.Type()
+			alloca, allocaSize := b.createTemporaryAlloca(arrayType, "index.alloca")
+			b.CreateStore(collection, alloca)
 			zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
-			ptr := b.CreateInBoundsGEP(arrayType, storage.ptr, []llvm.Value{zero, index}, "index.gep")
-			result := b.loadFromStorage(ptr, expr.Type(), "index.load")
-			b.endValueStorage(storage)
+			ptr := b.CreateInBoundsGEP(arrayType, alloca, []llvm.Value{zero, index}, "index.gep")
+			result := b.CreateLoad(arrayType.ElementType(), ptr, "index.load")
+			b.emitLifetimeEnd(alloca, allocaSize)
 			return result, nil
 		default:
 			panic("unknown *ssa.Index type")
@@ -2634,21 +2223,17 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 		}
 	case *ssa.Lookup: // map lookup
 		value := b.getValue(expr.X, getPos(expr))
+		index := b.getValue(expr.Index, getPos(expr))
 		valueType := expr.Type()
 		if expr.CommaOk {
 			valueType = valueType.(*types.Tuple).At(0).Type()
 		}
-		return b.createMapLookup(expr.X.Type().Underlying().(*types.Map).Key(), valueType, value, expr.Index, expr.CommaOk, expr.Pos())
+		return b.createMapLookup(expr.X.Type().Underlying().(*types.Map).Key(), valueType, value, index, expr.CommaOk, expr.Pos())
 	case *ssa.MakeChan:
 		return b.createMakeChan(expr), nil
 	case *ssa.MakeClosure:
 		return b.parseMakeClosure(expr)
 	case *ssa.MakeInterface:
-		if b.isOversizedAggregate(expr.X.Type()) {
-			typ := b.getLLVMType(expr.X.Type())
-			ptr := b.copyToIndirectStorage(b.getValuePointer(expr.X), typ, "interface.value")
-			return b.createMakeInterfaceFromPointer(ptr, expr.X.Type()), nil
-		}
 		val := b.getValue(expr.X, getPos(expr))
 		return b.createMakeInterface(val, expr.X.Type(), expr.Pos()), nil
 	case *ssa.MakeMap:
@@ -2682,7 +2267,8 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 		}
 		sliceSize := b.CreateBinOp(llvm.Mul, elemSizeValue, sliceCapCast, "makeslice.cap")
 		layoutValue := b.createObjectLayout(llvmElemType, expr.Pos())
-		slicePtr := b.createAlloc(sliceSize, layoutValue, elemAlign, "makeslice.buf")
+		slicePtr := b.createRuntimeCall("alloc", []llvm.Value{sliceSize, layoutValue}, "makeslice.buf")
+		slicePtr.AddCallSiteAttribute(0, b.ctx.CreateEnumAttribute(llvm.AttributeKindID("align"), uint64(elemAlign)))
 
 		// Extend or truncate if necessary. This is safe as we've already done
 		// the bounds check.
@@ -2715,8 +2301,7 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 			return b.createMapIteratorNext(rangeVal, llvmRangeVal, it), nil
 		}
 	case *ssa.Phi:
-		phiType := b.storedParamType(b.getLLVMType(expr.Type()), false)
-		phi := b.CreatePHI(phiType, "")
+		phi := b.CreatePHI(b.getLLVMType(expr.Type()), "")
 		b.phis = append(b.phis, phiNode{expr, phi})
 		return phi, nil
 	case *ssa.Range:
@@ -3719,7 +3304,8 @@ func (b *builder) createUnOp(unop *ssa.UnOp) (llvm.Value, error) {
 			return fn, nil
 		} else {
 			b.createNilCheck(unop.X, x, "deref")
-			return b.loadFromStorage(x, unop.Type(), ""), nil
+			load := b.CreateLoad(valueType, x, "")
+			return load, nil
 		}
 	case token.XOR: // ^x, toggle all bits in integer
 		return b.CreateXor(x, llvm.ConstInt(x.Type(), ^uint64(0), false), ""), nil

compiler/compiler_test.go

@@ -4,7 +4,6 @@ import (
 	"flag"
 	"go/types"
 	"os"
-	"regexp"
 	"strconv"
 	"strings"
 	"testing"
@@ -51,8 +50,6 @@ func TestCompiler(t *testing.T) {
 		{"channel.go", "", ""},
 		{"gc.go", "", ""},
 		{"zeromap.go", "", ""},
-		{"generics.go", "", ""},
-		{"large.go", "", ""},
 	}
 	if goMinor >= 20 {
 		tests = append(tests, testCase{"go1.20.go", "", ""})
@@ -60,9 +57,6 @@ func TestCompiler(t *testing.T) {
 	if goMinor >= 21 {
 		tests = append(tests, testCase{"go1.21.go", "", ""})
 	}
-	if goMinor >= 27 {
-		tests = append(tests, testCase{"go1.27.go", "", ""})
-	}
 
 	for _, tc := range tests {
 		name := tc.file
@@ -115,7 +109,7 @@ func TestCompiler(t *testing.T) {
 
 			// Update test if needed. Do not check the result.
 			if *flagUpdate {
-				err := os.WriteFile(outPath, []byte(normalizeIR(mod.String())), 0666)
+				err := os.WriteFile(outPath, []byte(mod.String()), 0666)
 				if err != nil {
 					t.Error("failed to write updated output file:", err)
 				}
@@ -127,137 +121,30 @@ func TestCompiler(t *testing.T) {
 				t.Fatal("failed to read golden file:", err)
 			}
 
-			if diff := diffIR(string(expected), mod.String()); diff != "" {
-				t.Errorf("output does not match expected output (re-run with -update to regenerate):\n%s", diff)
+			if !fuzzyEqualIR(mod.String(), string(expected)) {
+				t.Errorf("output does not match expected output:\n%s", mod.String())
 			}
 		})
 	}
 }
 
-func TestOptimizedLargeAggregateABI(t *testing.T) {
-	options := &compileopts.Options{Target: "wasm"}
-	mod, errs := testCompilePackage(t, options, "large-optimized.go")
-	if len(errs) != 0 {
-		for _, err := range errs {
-			t.Error(err)
-		}
-		return
+// fuzzyEqualIR returns true if the two LLVM IR strings passed in are roughly
+// equal. That means, only relevant lines are compared (excluding comments
+// etc.).
+func fuzzyEqualIR(s1, s2 string) bool {
+	lines1 := filterIrrelevantIRLines(strings.Split(s1, "\n"))
+	lines2 := filterIrrelevantIRLines(strings.Split(s2, "\n"))
+	if len(lines1) != len(lines2) {
+		return false
 	}
-	defer mod.Dispose()
-
-	passOptions := llvm.NewPassBuilderOptions()
-	defer passOptions.Dispose()
-	if err := mod.RunPasses("default<O2>", llvm.TargetMachine{}, passOptions); err != nil {
-		t.Fatal(err)
-	}
-
-	resultFn := mod.NamedFunction("main.makeLargeOptimizedValue")
-	if resultFn.IsNil() {
-		t.Fatal("missing function main.makeLargeOptimizedValue")
-	}
-	if resultType := resultFn.GlobalValueType().ReturnType(); resultType.TypeKind() != llvm.VoidTypeKind {
-		t.Errorf("large aggregate result was promoted to %s", resultType)
-	}
-
-	for _, name := range []string{
-		"main.makeLargeOptimizedValue",
-		"main.readLargeOptimizedValue",
-		"main.readMixedLargeOptimizedValue",
-	} {
-		fn := mod.NamedFunction(name)
-		if fn.IsNil() {
-			t.Fatalf("missing function %s", name)
-		}
-		if paramType := fn.GlobalValueType().ParamTypes()[0]; paramType.TypeKind() != llvm.PointerTypeKind {
-			t.Errorf("%s aggregate parameter was promoted to %s", name, paramType)
+	for i, line1 := range lines1 {
+		line2 := lines2[i]
+		if line1 != line2 {
+			return false
 		}
 	}
-}
 
-// normalizeIR canonicalizes LLVM-version-specific IR spellings for comparison
-// and when regenerating golden files.
-func normalizeIR(s string) string {
-	// Golden files are written using the pre-LLVM21 'nocapture' spelling,
-	// which LLVM printed before any co-occurring attribute such as
-	// 'readonly' (e.g. "ptr nocapture readonly"). LLVM 21+ prints the
-	// equivalent 'captures(none)' instead, and after such attributes (e.g.
-	// "ptr readonly captures(none)"). Normalize both name and position back
-	// to the old spelling.
-	s = normalizeCapturesAttr(s)
-
-	// LLVM 21+ also added an explicit 'nocreateundeforpoison' attribute to
-	// certain intrinsic declarations (e.g. llvm.umin) that were implicitly
-	// assumed not to create undef/poison before. It's unrelated to the
-	// behavior under test, so ignore it for comparison.
-	s = strings.ReplaceAll(s, "nocreateundeforpoison ", "")
-
-	// LLVM 22 dropped the (redundant) i64 size argument from
-	// llvm.lifetime.start/end. Normalize away that argument so golden files
-	// written against the two-argument form still match.
-	s = lifetimeSizeArgRe.ReplaceAllString(s, "$1")
-
-	return s
-}
-
-// diffIR compares two LLVM IR strings, ignoring irrelevant lines (comments,
-// empty lines, etc.) and normalizing LLVM-version-specific spellings via
-// normalizeIR. It returns "" when they are equal. Otherwise it returns a
-// compact diff of only the region that differs: the common prefix and suffix
-// are trimmed, then the differing expected lines (prefixed "-") are shown
-// followed by the differing actual lines (prefixed "+").
-func diffIR(expected, actual string) string {
-	exp := filterIrrelevantIRLines(strings.Split(normalizeIR(expected), "\n"))
-	act := filterIrrelevantIRLines(strings.Split(normalizeIR(actual), "\n"))
-
-	// Trim the common prefix.
-	start := 0
-	for start < len(exp) && start < len(act) && exp[start] == act[start] {
-		start++
-	}
-	// Trim the common suffix.
-	e, a := len(exp), len(act)
-	for e > start && a > start && exp[e-1] == act[a-1] {
-		e--
-		a--
-	}
-	if start == e && start == a {
-		return "" // equal
-	}
-
-	var b strings.Builder
-	b.WriteString("first difference at relevant line ")
-	b.WriteString(strconv.Itoa(start + 1))
-	b.WriteString(":\n")
-	for _, line := range exp[start:e] {
-		b.WriteString("- ")
-		b.WriteString(line)
-		b.WriteByte('\n')
-	}
-	for _, line := range act[start:a] {
-		b.WriteString("+ ")
-		b.WriteString(line)
-		b.WriteByte('\n')
-	}
-	return b.String()
-}
-
-// capturesNoneAttrRe matches a co-occurring attribute directly followed by
-// 'captures(none)', which is how LLVM 21+ orders these two attributes when
-// printing IR (the pre-LLVM21 'nocapture' attribute printed the other way
-// around).
-var capturesNoneAttrRe = regexp.MustCompile(`\b(readonly|readnone|writeonly|nonnull)\s+captures\(none\)`)
-
-// lifetimeSizeArgRe matches the i64 size argument of an
-// llvm.lifetime.start/end call or declaration, which LLVM 22 removed.
-var lifetimeSizeArgRe = regexp.MustCompile(`(@llvm\.lifetime\.(?:start|end)\.p0\()i64(?: immarg| \d+), `)
-
-// normalizeCapturesAttr rewrites LLVM 21+'s 'captures(none)' attribute back
-// to the pre-LLVM21 'nocapture' spelling and position, so golden IR files
-// written against LLVM <21 keep matching.
-func normalizeCapturesAttr(s string) string {
-	s = capturesNoneAttrRe.ReplaceAllString(s, "nocapture $1")
-	s = strings.ReplaceAll(s, "captures(none)", "nocapture")
-	return s
+	return true
 }
 
 // filterIrrelevantIRLines removes lines from the input slice of strings that
@@ -300,9 +187,9 @@ func TestCompilerErrors(t *testing.T) {
 		t.Error(err)
 	}
 	errorsFileString := strings.ReplaceAll(string(errorsFile), "\r\n", "\n")
-	for line := range strings.SplitSeq(errorsFileString, "\n") {
-		if after, ok := strings.CutPrefix(line, "// ERROR: "); ok {
-			expectedErrors = append(expectedErrors, after)
+	for _, line := range strings.Split(errorsFileString, "\n") {
+		if strings.HasPrefix(line, "// ERROR: ") {
+			expectedErrors = append(expectedErrors, strings.TrimPrefix(line, "// ERROR: "))
 		}
 	}
 
@@ -326,49 +213,6 @@ func TestCompilerErrors(t *testing.T) {
 	}
 }
 
-func TestAggregateValueCount(t *testing.T) {
-	t.Parallel()
-
-	ctx := llvm.NewContext()
-	defer ctx.Dispose()
-
-	byteType := ctx.Int8Type()
-	tests := []struct {
-		name     string
-		typ      llvm.Type
-		count    uint64
-		exceeded bool
-	}{
-		{"empty", llvm.ArrayType(byteType, 0), 0, false},
-		{"limit", llvm.ArrayType(byteType, 1024), 1024, false},
-		{"over limit", llvm.ArrayType(byteType, 1025), 0, true},
-		{"combined limit", ctx.StructType([]llvm.Type{
-			llvm.ArrayType(byteType, 512),
-			llvm.ArrayType(byteType, 512),
-		}, false), 1024, false},
-		{"combined over limit", ctx.StructType([]llvm.Type{
-			llvm.ArrayType(byteType, 1000),
-			llvm.ArrayType(byteType, 1000),
-		}, false), 0, true},
-		{"comma-ok over limit", ctx.StructType([]llvm.Type{
-			llvm.ArrayType(byteType, 1024),
-			ctx.Int1Type(),
-		}, false), 0, true},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			count, exceeded := aggregateValueCount(test.typ, 0)
-			if exceeded != test.exceeded {
-				t.Errorf("expected exceeded=%t, got %t", test.exceeded, exceeded)
-			}
-			if !exceeded && count != test.count {
-				t.Errorf("expected count=%d, got %d", test.count, count)
-			}
-		})
-	}
-}
-
 // Build a package given a number of compiler options and a file.
 func testCompilePackage(t *testing.T, options *compileopts.Options, file string) (llvm.Module, []error) {
 	target, err := compileopts.LoadTarget(options)
@@ -413,7 +257,5 @@ func testCompilePackage(t *testing.T, options *compileopts.Options, file string)
 	// Compile AST to IR.
 	program := lprogram.LoadSSA()
 	pkg := lprogram.MainPkg()
-	ssaPkg := program.Package(pkg.Pkg)
-	ssaPkg.Build()
-	return CompilePackage(file, pkg, ssaPkg, machine, compilerConfig, false)
+	return CompilePackage(file, pkg, program.Package(pkg.Pkg), machine, compilerConfig, false)
 }

compiler/defer.go

@@ -32,7 +32,7 @@ func (b *builder) supportsRecover() bool {
 		// proposal of WebAssembly:
 		// https://github.com/WebAssembly/exception-handling
 		return false
-	case "xtensa":
+	case "riscv64", "xtensa":
 		// TODO: add support for these architectures
 		return false
 	default:
@@ -60,6 +60,10 @@ func (b *builder) deferInitFunc() {
 	b.deferExprFuncs = make(map[ssa.Value]int)
 	b.deferBuiltinFuncs = make(map[ssa.Value]deferBuiltin)
 
+	// Create defer list pointer.
+	b.deferPtr = b.CreateAlloca(b.dataPtrType, "deferPtr")
+	b.CreateStore(llvm.ConstPointerNull(b.dataPtrType), b.deferPtr)
+
 	if b.hasDeferFrame() {
 		// Set up the defer frame with the current stack pointer.
 		// This assumes that the stack pointer doesn't move outside of the
@@ -69,22 +73,12 @@ func (b *builder) deferInitFunc() {
 		// in the setjmp-like inline assembly.
 		deferFrameType := b.getLLVMRuntimeType("deferFrame")
 		b.deferFrame = b.CreateAlloca(deferFrameType, "deferframe.buf")
-		// The field index must match the DeferPtr field in runtime.deferFrame,
-		// defined in src/runtime/panic.go.
-		b.deferPtr = b.CreateInBoundsGEP(deferFrameType, b.deferFrame, []llvm.Value{
-			llvm.ConstInt(b.ctx.Int32Type(), 0, false),
-			llvm.ConstInt(b.ctx.Int32Type(), 6, false), // DeferPtr field
-		}, "deferPtr")
 		stackPointer := b.readStackPointer()
 		b.createRuntimeCall("setupDeferFrame", []llvm.Value{b.deferFrame, stackPointer}, "")
 
 		// Create the landing pad block, which is where control transfers after
 		// a panic.
 		b.landingpad = b.ctx.AddBasicBlock(b.llvmFn, "lpad")
-	} else {
-		// Create defer list pointer.
-		b.deferPtr = b.CreateAlloca(b.dataPtrType, "deferPtr")
-		b.CreateStore(llvm.ConstPointerNull(b.dataPtrType), b.deferPtr)
 	}
 }
 
@@ -106,18 +100,17 @@ func (b *builder) createLandingPad() {
 
 	// Continue at the 'recover' block, which returns to the parent in an
 	// appropriate way.
-	b.CreateBr(b.blockInfo[b.fn.Recover.Index].entry)
+	b.CreateBr(b.blockEntries[b.fn.Recover])
 }
 
-// Create a checkpoint (similar to setjmp). This emits inline assembly that
-// stores the current program counter inside the ptr address (actually
-// ptr+sizeof(ptr)) and then returns a boolean indicating whether this is the
-// normal flow (false) or we jumped here from somewhere else (true).
-func (b *builder) createCheckpoint(ptr llvm.Value) llvm.Value {
+// createInvokeCheckpoint saves the function state at the given point, to
+// continue at the landing pad if a panic happened. This is implemented using a
+// setjmp-like construct.
+func (b *builder) createInvokeCheckpoint() {
 	// Construct inline assembly equivalents of setjmp.
 	// The assembly works as follows:
-	//   * Registers are either clobbered or, on 386, saved for longjmp to
-	//     restore if the ABI requires them to survive calls.
+	//   * All registers (both callee-saved and caller saved) are clobbered
+	//     after the inline assembly returns.
 	//   * The assembly stores the address just past the end of the assembly
 	//     into the jump buffer.
 	//   * The return value (eax, rax, r0, etc) is set to zero in the inline
@@ -130,12 +123,8 @@ func (b *builder) createCheckpoint(ptr llvm.Value) llvm.Value {
 		asmString = `
 xorl %eax, %eax
 movl $$1f, 4(%ebx)
-movl %ebx, 8(%ebx)
-movl %esi, 12(%ebx)
-movl %edi, 16(%ebx)
-movl %ebp, 20(%ebx)
 1:`
-		constraints = "={eax},{ebx},~{ecx},~{edx},~{xmm0},~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{fpsr},~{fpcr},~{flags},~{dirflag},~{memory}"
+		constraints = "={eax},{ebx},~{ebx},~{ecx},~{edx},~{esi},~{edi},~{ebp},~{xmm0},~{xmm1},~{xmm2},~{xmm3},~{xmm4},~{xmm5},~{xmm6},~{xmm7},~{fpsr},~{fpcr},~{flags},~{dirflag},~{memory}"
 		// This doesn't include the floating point stack because TinyGo uses
 		// newer floating point instructions.
 	case "x86_64":
@@ -217,192 +206,60 @@ sw $$ra, 4($$5)
 			// So only add them when using hardfloat.
 			constraints += ",~{$f0},~{$f1},~{$f2},~{$f3},~{$f4},~{$f5},~{$f6},~{$f7},~{$f8},~{$f9},~{$f10},~{$f11},~{$f12},~{$f13},~{$f14},~{$f15},~{$f16},~{$f17},~{$f18},~{$f19},~{$f20},~{$f21},~{$f22},~{$f23},~{$f24},~{$f25},~{$f26},~{$f27},~{$f28},~{$f29},~{$f30},~{$f31}"
 		}
-	case "riscv32", "riscv64":
-		if b.archFamily() == "riscv32" {
-			asmString = `
+	case "riscv32":
+		asmString = `
 la a2, 1f
 sw a2, 4(a1)
 li a0, 0
 1:`
-		} else {
-			asmString = `
-la a2, 1f
-sd a2, 8(a1)
-li a0, 0
-1:`
-		}
 		constraints = "={a0},{a1},~{a1},~{a2},~{a3},~{a4},~{a5},~{a6},~{a7},~{s0},~{s1},~{s2},~{s3},~{s4},~{s5},~{s6},~{s7},~{s8},~{s9},~{s10},~{s11},~{t0},~{t1},~{t2},~{t3},~{t4},~{t5},~{t6},~{ra},~{f0},~{f1},~{f2},~{f3},~{f4},~{f5},~{f6},~{f7},~{f8},~{f9},~{f10},~{f11},~{f12},~{f13},~{f14},~{f15},~{f16},~{f17},~{f18},~{f19},~{f20},~{f21},~{f22},~{f23},~{f24},~{f25},~{f26},~{f27},~{f28},~{f29},~{f30},~{f31},~{memory}"
 	default:
 		// This case should have been handled by b.supportsRecover().
 		b.addError(b.fn.Pos(), "unknown architecture for defer: "+b.archFamily())
 	}
-	asmType := llvm.FunctionType(resultType, []llvm.Type{b.dataPtrType}, false)
+	asmType := llvm.FunctionType(resultType, []llvm.Type{b.deferFrame.Type()}, false)
 	asm := llvm.InlineAsm(asmType, asmString, constraints, false, false, 0, false)
-	result := b.CreateCall(asmType, asm, []llvm.Value{ptr}, "setjmp")
+	result := b.CreateCall(asmType, asm, []llvm.Value{b.deferFrame}, "setjmp")
 	result.AddCallSiteAttribute(-1, b.ctx.CreateEnumAttribute(llvm.AttributeKindID("returns_twice"), 0))
 	isZero := b.CreateICmp(llvm.IntEQ, result, llvm.ConstInt(resultType, 0, false), "setjmp.result")
-	return isZero
-}
-
-// createInvokeCheckpoint saves the function state at the given point, to
-// continue at the landing pad if a panic happened. This is implemented using a
-// setjmp-like construct.
-func (b *builder) createInvokeCheckpoint() {
-	isZero := b.createCheckpoint(b.deferFrame)
 	continueBB := b.insertBasicBlock("")
 	b.CreateCondBr(isZero, continueBB, b.landingpad)
 	b.SetInsertPointAtEnd(continueBB)
-	b.currentBlockInfo.exit = continueBB
+	b.blockExits[b.currentBlock] = continueBB
 }
 
-// createFaultCheckpoint is like createInvokeCheckpoint but for use in fault
-// blocks (e.g., bounds check failures). Unlike createInvokeCheckpoint, it does
-// not update currentBlockInfo.exit because the fault block is a dead-end that
-// does not participate in phi node resolution.
-func (b *builder) createFaultCheckpoint() {
-	isZero := b.createCheckpoint(b.deferFrame)
-	continueBB := b.insertBasicBlock("")
-	b.CreateCondBr(isZero, continueBB, b.landingpad)
-	b.SetInsertPointAtEnd(continueBB)
-}
+// isInLoop checks if there is a path from a basic block to itself.
+func isInLoop(start *ssa.BasicBlock) bool {
+	// Use a breadth-first search to scan backwards through the block graph.
+	queue := []*ssa.BasicBlock{start}
+	checked := map[*ssa.BasicBlock]struct{}{}
 
-// isInLoop checks if there is a path from the current block to itself.
-// Use Tarjan's strongly connected components algorithm to search for cycles.
-// A one-node SCC is a cycle iff there is an edge from the node to itself.
-// A multi-node SCC is always a cycle.
-// https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm
-func (b *builder) isInLoop() bool {
-	if b.currentBlockInfo.tarjan.lowLink == 0 {
-		b.strongConnect(b.currentBlock)
-	}
-	return b.currentBlockInfo.tarjan.cyclic
-}
+	for len(queue) > 0 {
+		// pop a block off of the queue
+		block := queue[len(queue)-1]
+		queue = queue[:len(queue)-1]
 
-func (b *builder) strongConnect(block *ssa.BasicBlock) {
-	// Assign a new index.
-	// Indices start from 1 so that 0 can be used as a sentinel.
-	assignedIndex := b.tarjanIndex + 1
-	b.tarjanIndex = assignedIndex
-
-	// Apply the new index.
-	blockIndex := block.Index
-	node := &b.blockInfo[blockIndex].tarjan
-	node.lowLink = assignedIndex
-
-	// Push the node onto the stack.
-	node.onStack = true
-	b.tarjanStack = append(b.tarjanStack, uint(blockIndex))
-
-	// Process the successors.
-	for _, successor := range block.Succs {
-		// Look up the successor's state.
-		successorIndex := successor.Index
-		if successorIndex == blockIndex {
-			// Handle a self-cycle specially.
-			node.cyclic = true
-			continue
-		}
-		successorNode := &b.blockInfo[successorIndex].tarjan
-
-		switch {
-		case successorNode.lowLink == 0:
-			// This node has not yet been visisted.
-			b.strongConnect(successor)
-
-		case !successorNode.onStack:
-			// This node has been visited, but is in a different SCC.
-			// Ignore it, and do not update lowLink.
-			continue
-		}
-
-		// Update the lowLink index.
-		// This always uses the min-of-lowlink instead of using index in the on-stack case.
-		// This is done for two reasons:
-		// 1. The lowLink update can be shared between the new-node and on-stack cases.
-		// 2. The assigned index does not need to be saved - it is only needed for root node detection.
-		if successorNode.lowLink < node.lowLink {
-			node.lowLink = successorNode.lowLink
-		}
-	}
-
-	if node.lowLink == assignedIndex {
-		// This is a root node.
-		// Pop the SCC off the stack.
-		stack := b.tarjanStack
-		top := stack[len(stack)-1]
-		stack = stack[:len(stack)-1]
-		blocks := b.blockInfo
-		topNode := &blocks[top].tarjan
-		topNode.onStack = false
-
-		if top != uint(blockIndex) {
-			// The root node is not the only node in the SCC.
-			// Mark all nodes in this SCC as cyclic.
-			topNode.cyclic = true
-			for top != uint(blockIndex) {
-				top = stack[len(stack)-1]
-				stack = stack[:len(stack)-1]
-				topNode = &blocks[top].tarjan
-				topNode.onStack = false
-				topNode.cyclic = true
+		// Search through predecessors.
+		// Searching backwards means that this is pretty fast when the block is close to the start of the function.
+		// Defers are often placed near the start of the function.
+		for _, pred := range block.Preds {
+			if pred == start {
+				// cycle found
+				return true
 			}
+
+			if _, ok := checked[pred]; ok {
+				// block already checked
+				continue
+			}
+
+			// add to queue and checked map
+			queue = append(queue, pred)
+			checked[pred] = struct{}{}
 		}
-
-		b.tarjanStack = stack
 	}
-}
 
-// tarjanNode holds per-block state for isInLoop and strongConnect.
-type tarjanNode struct {
-	// lowLink is the index of the first visited node that is reachable from this block.
-	// The lowLink indices are assigned by the SCC search, and do not correspond to b.Index.
-	// A lowLink of 0 is used as a sentinel to mark a node which has not yet been visited.
-	lowLink uint
-
-	// onStack tracks whether this node is currently on the SCC search stack.
-	onStack bool
-
-	// cyclic indicates whether this block is in a loop.
-	// If lowLink is 0, strongConnect must be called before reading this field.
-	cyclic bool
-}
-
-type llvmValueList struct {
-	values []llvm.Value
-	types  []llvm.Type
-}
-
-func newLLVMValueList(values ...llvm.Value) llvmValueList {
-	var list llvmValueList
-	list.append(values...)
-	return list
-}
-
-func (l *llvmValueList) append(values ...llvm.Value) {
-	for _, value := range values {
-		l.values = append(l.values, value)
-		l.types = append(l.types, value.Type())
-	}
-}
-
-func (l *llvmValueList) appendSSAValues(values []ssa.Value, lower func(ssa.Value) llvm.Value) {
-	for _, value := range values {
-		l.append(lower(value))
-	}
-}
-
-func (b *builder) loadDeferredCallParams(structType llvm.Type, ptr llvm.Value) []llvm.Value {
-	fieldTypes := structType.StructElementTypes()
-	values := make([]llvm.Value, 0, len(fieldTypes)-2)
-	zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
-	for i := 2; i < len(fieldTypes); i++ {
-		fieldPtr := b.CreateInBoundsGEP(structType, ptr, []llvm.Value{
-			zero,
-			llvm.ConstInt(b.ctx.Int32Type(), uint64(i), false),
-		}, "gep")
-		values = append(values, b.CreateLoad(fieldTypes[i], fieldPtr, "param"))
-	}
-	return values
+	return false
 }
 
 // createDefer emits a single defer instruction, to be run when this function
@@ -412,28 +269,31 @@ func (b *builder) createDefer(instr *ssa.Defer) {
 	// make a linked list.
 	next := b.CreateLoad(b.dataPtrType, b.deferPtr, "defer.next")
 
-	var values llvmValueList
-	lowerArgument := func(value ssa.Value) llvm.Value {
-		return b.getCallArgument(value, false)
-	}
+	var values []llvm.Value
+	valueTypes := []llvm.Type{b.uintptrType, next.Type()}
 	if instr.Call.IsInvoke() {
 		// Method call on an interface.
 
 		// Get callback type number.
-		key := b.getInvokeFunctionName(&instr.Call)
-		if _, ok := b.deferInvokeFuncs[key]; !ok {
-			b.deferInvokeFuncs[key] = len(b.allDeferFuncs)
+		methodName := instr.Call.Method.FullName()
+		if _, ok := b.deferInvokeFuncs[methodName]; !ok {
+			b.deferInvokeFuncs[methodName] = len(b.allDeferFuncs)
 			b.allDeferFuncs = append(b.allDeferFuncs, &instr.Call)
 		}
-		callback := llvm.ConstInt(b.uintptrType, uint64(b.deferInvokeFuncs[key]), false)
+		callback := llvm.ConstInt(b.uintptrType, uint64(b.deferInvokeFuncs[methodName]), false)
 
 		// Collect all values to be put in the struct (starting with
 		// runtime._defer fields, followed by the call parameters).
 		itf := b.getValue(instr.Call.Value, getPos(instr)) // interface
 		typecode := b.CreateExtractValue(itf, 0, "invoke.func.typecode")
 		receiverValue := b.CreateExtractValue(itf, 1, "invoke.func.receiver")
-		values = newLLVMValueList(callback, next, typecode, receiverValue)
-		values.appendSSAValues(instr.Call.Args, lowerArgument)
+		values = []llvm.Value{callback, next, typecode, receiverValue}
+		valueTypes = append(valueTypes, b.dataPtrType, b.dataPtrType)
+		for _, arg := range instr.Call.Args {
+			val := b.getValue(arg, getPos(instr))
+			values = append(values, val)
+			valueTypes = append(valueTypes, val.Type())
+		}
 
 	} else if callee, ok := instr.Call.Value.(*ssa.Function); ok {
 		// Regular function call.
@@ -445,11 +305,12 @@ func (b *builder) createDefer(instr *ssa.Defer) {
 
 		// Collect all values to be put in the struct (starting with
 		// runtime._defer fields).
-		values = newLLVMValueList(callback, next)
-		exported := b.getFunctionInfo(callee).exported
-		values.appendSSAValues(instr.Call.Args, func(value ssa.Value) llvm.Value {
-			return b.getCallArgument(value, exported)
-		})
+		values = []llvm.Value{callback, next}
+		for _, param := range instr.Call.Args {
+			llvmParam := b.getValue(param, getPos(instr))
+			values = append(values, llvmParam)
+			valueTypes = append(valueTypes, llvmParam.Type())
+		}
 
 	} else if makeClosure, ok := instr.Call.Value.(*ssa.MakeClosure); ok {
 		// Immediately applied function literal with free variables.
@@ -472,9 +333,14 @@ func (b *builder) createDefer(instr *ssa.Defer) {
 		// Collect all values to be put in the struct (starting with
 		// runtime._defer fields, followed by all parameters including the
 		// context pointer).
-		values = newLLVMValueList(callback, next)
-		values.appendSSAValues(instr.Call.Args, lowerArgument)
-		values.append(context)
+		values = []llvm.Value{callback, next}
+		for _, param := range instr.Call.Args {
+			llvmParam := b.getValue(param, getPos(instr))
+			values = append(values, llvmParam)
+			valueTypes = append(valueTypes, llvmParam.Type())
+		}
+		values = append(values, context)
+		valueTypes = append(valueTypes, context.Type())
 
 	} else if builtin, ok := instr.Call.Value.(*ssa.Builtin); ok {
 		var argTypes []types.Type
@@ -497,8 +363,11 @@ func (b *builder) createDefer(instr *ssa.Defer) {
 
 		// Collect all values to be put in the struct (starting with
 		// runtime._defer fields).
-		values = newLLVMValueList(callback, next)
-		values.append(argValues...)
+		values = []llvm.Value{callback, next}
+		for _, param := range argValues {
+			values = append(values, param)
+			valueTypes = append(valueTypes, param.Type())
+		}
 
 	} else {
 		funcValue := b.getValue(instr.Call.Value, getPos(instr))
@@ -513,33 +382,34 @@ func (b *builder) createDefer(instr *ssa.Defer) {
 		// Collect all values to be put in the struct (starting with
 		// runtime._defer fields, followed by all parameters including the
 		// context pointer).
-		values = newLLVMValueList(callback, next, funcValue)
-		values.appendSSAValues(instr.Call.Args, lowerArgument)
+		values = []llvm.Value{callback, next, funcValue}
+		valueTypes = append(valueTypes, funcValue.Type())
+		for _, param := range instr.Call.Args {
+			llvmParam := b.getValue(param, getPos(instr))
+			values = append(values, llvmParam)
+			valueTypes = append(valueTypes, llvmParam.Type())
+		}
 	}
 
 	// Make a struct out of the collected values to put in the deferred call
 	// struct.
-	deferredCallType := b.ctx.StructType(values.types, false)
+	deferredCallType := b.ctx.StructType(valueTypes, false)
 	deferredCall := llvm.ConstNull(deferredCallType)
-	for i, value := range values.values {
+	for i, value := range values {
 		deferredCall = b.CreateInsertValue(deferredCall, value, i, "")
 	}
 
 	// Put this struct in an allocation.
 	var alloca llvm.Value
-	if instr.Block() != b.currentBlock {
-		panic("block mismatch")
-	}
-	if !b.isInLoop() {
+	if !isInLoop(instr.Block()) {
 		// This can safely use a stack allocation.
 		alloca = llvmutil.CreateEntryBlockAlloca(b.Builder, deferredCallType, "defer.alloca")
 	} else {
 		// This may be hit a variable number of times, so use a heap allocation.
 		size := b.targetData.TypeAllocSize(deferredCallType)
 		sizeValue := llvm.ConstInt(b.uintptrType, size, false)
-		layoutValue := b.createObjectLayout(deferredCallType, instr.Pos())
-		align := b.targetData.ABITypeAlignment(deferredCallType)
-		alloca = b.createAlloc(sizeValue, layoutValue, align, "defer.alloc.call")
+		nilPtr := llvm.ConstNull(b.dataPtrType)
+		alloca = b.createRuntimeCall("alloc", []llvm.Value{sizeValue, nilPtr}, "defer.alloc.call")
 	}
 	if b.NeedsStackObjects {
 		b.trackPointer(alloca)
@@ -623,11 +493,19 @@ func (b *builder) createRunDefers() {
 				valueTypes = append(valueTypes, b.dataPtrType, b.dataPtrType)
 			}
 
-			valueTypes = b.appendStoredValueTypes(valueTypes, callback.Args, false)
+			for _, arg := range callback.Args {
+				valueTypes = append(valueTypes, b.getLLVMType(arg.Type()))
+			}
 
 			// Extract the params from the struct (including receiver).
+			forwardParams := []llvm.Value{}
+			zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
 			deferredCallType := b.ctx.StructType(valueTypes, false)
-			forwardParams := b.loadDeferredCallParams(deferredCallType, deferData)
+			for i := 2; i < len(valueTypes); i++ {
+				gep := b.CreateInBoundsGEP(deferredCallType, deferData, []llvm.Value{zero, llvm.ConstInt(b.ctx.Int32Type(), uint64(i), false)}, "gep")
+				forwardParam := b.CreateLoad(valueTypes[i], gep, "param")
+				forwardParams = append(forwardParams, forwardParam)
+			}
 
 			var fnPtr llvm.Value
 			var fnType llvm.Type
@@ -656,7 +534,6 @@ func (b *builder) createRunDefers() {
 				// with a strict calling convention.
 				forwardParams = append(forwardParams, llvm.Undef(b.dataPtrType))
 			}
-			forwardParams = b.prependIndirectResult(callback.Signature(), false, forwardParams, "defer.result")
 
 			b.createCall(fnType, fnPtr, forwardParams, "")
 
@@ -665,21 +542,27 @@ func (b *builder) createRunDefers() {
 
 			// Get the real defer struct type and cast to it.
 			valueTypes := []llvm.Type{b.uintptrType, b.dataPtrType}
-			exported := b.getFunctionInfo(callback).exported
-			valueTypes = b.appendStoredParamTypes(valueTypes, getParams(callback.Signature), exported)
+			for _, param := range getParams(callback.Signature) {
+				valueTypes = append(valueTypes, b.getLLVMType(param.Type()))
+			}
 			deferredCallType := b.ctx.StructType(valueTypes, false)
 
 			// Extract the params from the struct.
-			forwardParams := b.loadDeferredCallParams(deferredCallType, deferData)
+			forwardParams := []llvm.Value{}
+			zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
+			for i := range getParams(callback.Signature) {
+				gep := b.CreateInBoundsGEP(deferredCallType, deferData, []llvm.Value{zero, llvm.ConstInt(b.ctx.Int32Type(), uint64(i+2), false)}, "gep")
+				forwardParam := b.CreateLoad(valueTypes[i+2], gep, "param")
+				forwardParams = append(forwardParams, forwardParam)
+			}
 
 			// Plain TinyGo functions add some extra parameters to implement async functionality and function receivers.
 			// These parameters should not be supplied when calling into an external C/ASM function.
-			if !exported {
+			if !b.getFunctionInfo(callback).exported {
 				// Add the context parameter. We know it is ignored by the receiving
 				// function, but we have to pass one anyway.
 				forwardParams = append(forwardParams, llvm.Undef(b.dataPtrType))
 			}
-			forwardParams = b.prependIndirectResult(callback.Signature, exported, forwardParams, "defer.result")
 
 			// Call real function.
 			fnType, fn := b.getFunction(callback)
@@ -689,16 +572,24 @@ func (b *builder) createRunDefers() {
 			// Get the real defer struct type and cast to it.
 			fn := callback.Fn.(*ssa.Function)
 			valueTypes := []llvm.Type{b.uintptrType, b.dataPtrType}
-			valueTypes = b.appendStoredParamTypes(valueTypes, getParams(fn.Signature), false)
+			params := fn.Signature.Params()
+			for i := 0; i < params.Len(); i++ {
+				valueTypes = append(valueTypes, b.getLLVMType(params.At(i).Type()))
+			}
 			valueTypes = append(valueTypes, b.dataPtrType) // closure
 			deferredCallType := b.ctx.StructType(valueTypes, false)
 
 			// Extract the params from the struct.
-			forwardParams := b.loadDeferredCallParams(deferredCallType, deferData)
+			forwardParams := []llvm.Value{}
+			zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
+			for i := 2; i < len(valueTypes); i++ {
+				gep := b.CreateInBoundsGEP(deferredCallType, deferData, []llvm.Value{zero, llvm.ConstInt(b.ctx.Int32Type(), uint64(i), false)}, "")
+				forwardParam := b.CreateLoad(valueTypes[i], gep, "param")
+				forwardParams = append(forwardParams, forwardParam)
+			}
 
 			// Call deferred function.
 			fnType, llvmFn := b.getFunction(fn)
-			forwardParams = b.prependIndirectResult(fn.Signature, false, forwardParams, "defer.result")
 			b.createCall(fnType, llvmFn, forwardParams, "")
 		case *ssa.Builtin:
 			db := b.deferBuiltinFuncs[callback]
@@ -708,14 +599,20 @@ func (b *builder) createRunDefers() {
 
 			//Get signature from call results
 			params := callback.Type().Underlying().(*types.Signature).Params()
-			for v := range params.Variables() {
-				valueTypes = append(valueTypes, b.getLLVMType(v.Type()))
+			for i := 0; i < params.Len(); i++ {
+				valueTypes = append(valueTypes, b.getLLVMType(params.At(i).Type()))
 			}
 
 			deferredCallType := b.ctx.StructType(valueTypes, false)
 
 			// Extract the params from the struct.
-			argValues := b.loadDeferredCallParams(deferredCallType, deferData)
+			var argValues []llvm.Value
+			zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
+			for i := 0; i < params.Len(); i++ {
+				gep := b.CreateInBoundsGEP(deferredCallType, deferData, []llvm.Value{zero, llvm.ConstInt(b.ctx.Int32Type(), uint64(i+2), false)}, "gep")
+				forwardParam := b.CreateLoad(valueTypes[i+2], gep, "param")
+				argValues = append(argValues, forwardParam)
+			}
 
 			_, err := b.createBuiltin(db.argTypes, argValues, db.callName, db.pos)
 			if err != nil {

compiler/func.go

@@ -10,91 +10,6 @@ import (
 	"tinygo.org/x/go-llvm"
 )
 
-// LLVM recursively expands each struct field and array element in parameters
-// and results into separate values. It gets very slow with too many values, so
-// pass larger aggregates indirectly before LLVM expands them.
-const maxDirectAggregateValues = 1024
-
-func (c *compilerContext) getLLVMResultType(sig *types.Signature) llvm.Type {
-	switch sig.Results().Len() {
-	case 0:
-		return c.ctx.VoidType()
-	case 1:
-		return c.getLLVMType(sig.Results().At(0).Type())
-	default:
-		results := make([]llvm.Type, sig.Results().Len())
-		for i := range results {
-			results[i] = c.getLLVMType(sig.Results().At(i).Type())
-		}
-		return c.ctx.StructType(results, false)
-	}
-}
-
-func (c *compilerContext) hasIndirectResult(sig *types.Signature) (llvm.Type, bool) {
-	resultType := c.getLLVMResultType(sig)
-	return resultType, c.isIndirectAggregate(resultType)
-}
-
-func (c *compilerContext) isIndirectAggregate(typ llvm.Type) bool {
-	switch typ.TypeKind() {
-	case llvm.ArrayTypeKind, llvm.StructTypeKind:
-		_, exceeded := aggregateValueCount(typ, 0)
-		return exceeded
-	default:
-		return false
-	}
-}
-
-func aggregateValueCount(typ llvm.Type, count uint64) (uint64, bool) {
-	switch typ.TypeKind() {
-	case llvm.ArrayTypeKind:
-		length := uint64(typ.ArrayLength())
-		if length == 0 {
-			return count, false
-		}
-		elementCount, exceeded := aggregateValueCount(typ.ElementType(), 0)
-		if exceeded {
-			return count, true
-		}
-		if elementCount != 0 && length > (maxDirectAggregateValues-count)/elementCount {
-			return count, true
-		}
-		return count + length*elementCount, false
-	case llvm.StructTypeKind:
-		for _, field := range typ.StructElementTypes() {
-			var exceeded bool
-			count, exceeded = aggregateValueCount(field, count)
-			if exceeded {
-				return count, true
-			}
-		}
-		return count, false
-	default:
-		count++
-		return count, count > maxDirectAggregateValues
-	}
-}
-
-func isLLVMValueType(typ types.Type) bool {
-	switch typ := typ.Underlying().(type) {
-	case *types.Basic:
-		return typ.Kind() != types.Invalid
-	case *types.Array:
-		return isLLVMValueType(typ.Elem())
-	case *types.Struct:
-		for field := range typ.Fields() {
-			if !isLLVMValueType(field.Type()) {
-				return false
-			}
-		}
-		return true
-	case *types.Chan, *types.Interface, *types.Map, *types.Pointer, *types.Signature, *types.Slice:
-		return true
-	default:
-		return false
-	}
-}
-
 // createFuncValue creates a function value from a raw function pointer with no
 // context.
 func (b *builder) createFuncValue(funcPtr, context llvm.Value, sig *types.Signature) llvm.Value {
@@ -133,18 +48,28 @@ func (c *compilerContext) getFuncType(typ *types.Signature) llvm.Type {
 
 // getLLVMFunctionType returns a LLVM function type for a given signature.
 func (c *compilerContext) getLLVMFunctionType(typ *types.Signature) llvm.Type {
-	returnType, indirectResult := c.hasIndirectResult(typ)
+	// Get the return type.
+	var returnType llvm.Type
+	switch typ.Results().Len() {
+	case 0:
+		// No return values.
+		returnType = c.ctx.VoidType()
+	case 1:
+		// Just one return value.
+		returnType = c.getLLVMType(typ.Results().At(0).Type())
+	default:
+		// Multiple return values. Put them together in a struct.
+		// This appears to be the common way to handle multiple return values in
+		// LLVM.
+		members := make([]llvm.Type, typ.Results().Len())
+		for i := 0; i < typ.Results().Len(); i++ {
+			members[i] = c.getLLVMType(typ.Results().At(i).Type())
+		}
+		returnType = c.ctx.StructType(members, false)
+	}
 
 	// Get the parameter types.
 	var paramTypes []llvm.Type
-	if indirectResult {
-		// LLVM expands aggregate returns into scalar leaves before deciding
-		// whether to pass them indirectly, so a large IR return can exhaust
-		// memory. Returning void avoids that expansion and cannot be demoted
-		// again. Keep the result pointer first so the context remains last.
-		paramTypes = append(paramTypes, c.dataPtrType)
-		returnType = c.ctx.VoidType()
-	}
 	if typ.Recv() != nil {
 		recv := c.getLLVMType(typ.Recv().Type())
 		if recv.StructName() == "runtime._interface" {
@@ -156,8 +81,8 @@ func (c *compilerContext) getLLVMFunctionType(typ *types.Signature) llvm.Type {
 			paramTypes = append(paramTypes, info.llvmType)
 		}
 	}
-	for v := range typ.Params().Variables() {
-		subType := c.getLLVMType(v.Type())
+	for i := 0; i < typ.Params().Len(); i++ {
+		subType := c.getLLVMType(typ.Params().At(i).Type())
 		for _, info := range c.expandFormalParamType(subType, "", nil) {
 			paramTypes = append(paramTypes, info.llvmType)
 		}
@@ -187,7 +112,7 @@ func (b *builder) parseMakeClosure(expr *ssa.MakeClosure) (llvm.Value, error) {
 
 	// Store the bound variables in a single object, allocating it on the heap
 	// if necessary.
-	context := b.emitPointerPack(boundVars, expr.Pos())
+	context := b.emitPointerPack(boundVars)
 
 	// Create the closure.
 	_, fn := b.getFunction(f)

compiler/gc.go

@@ -5,38 +5,11 @@ package compiler
 
 import (
 	"go/token"
-	"slices"
 
 	"golang.org/x/tools/go/ssa"
 	"tinygo.org/x/go-llvm"
 )
 
-// Heap-allocate a buffer of the given size. This will typically call
-// runtime.alloc.
-func (b *builder) createAlloc(sizeValue, layoutValue llvm.Value, align int, comment string) llvm.Value {
-	// Normally allocate using "runtime.alloc", but use "runtime.alloc_noheap"
-	// if the //go:noheap pragma is used.
-	allocFunc := "alloc"
-	if b.info.noheap {
-		allocFunc = "alloc_noheap"
-	}
-
-	// Allocs that don't allocate anything can return an architecture-specific
-	// sentinel value.
-	if !sizeValue.IsAConstantInt().IsNil() && sizeValue.ZExtValue() == 0 {
-		allocFunc = "alloc_zero"
-	}
-
-	// Make the runtime call.
-	call := b.createRuntimeCall(allocFunc, []llvm.Value{sizeValue, layoutValue}, comment)
-	if align == 0 || align&(align-1) != 0 {
-		panic("invalid alignment")
-	}
-	call.AddCallSiteAttribute(0, b.ctx.CreateEnumAttribute(llvm.AttributeKindID("align"), uint64(align)))
-
-	return call
-}
-
 // trackExpr inserts pointer tracking intrinsics for the GC if the expression is
 // one of the expressions that need this.
 func (b *builder) trackExpr(expr ssa.Value, value llvm.Value) {
@@ -89,7 +62,7 @@ func (b *builder) trackValue(value llvm.Value) {
 			return
 		}
 		numElements := typ.StructElementTypesCount()
-		for i := range numElements {
+		for i := 0; i < numElements; i++ {
 			subValue := b.CreateExtractValue(value, i, "")
 			b.trackValue(subValue)
 		}
@@ -98,7 +71,7 @@ func (b *builder) trackValue(value llvm.Value) {
 			return
 		}
 		numElements := typ.ArrayLength()
-		for i := range numElements {
+		for i := 0; i < numElements; i++ {
 			subValue := b.CreateExtractValue(value, i, "")
 			b.trackValue(subValue)
 		}
@@ -119,11 +92,13 @@ func typeHasPointers(t llvm.Type) bool {
 	case llvm.PointerTypeKind:
 		return true
 	case llvm.StructTypeKind:
-		return slices.ContainsFunc(t.StructElementTypes(), typeHasPointers)
-	case llvm.ArrayTypeKind:
-		if t.ArrayLength() == 0 {
-			return false
+		for _, subType := range t.StructElementTypes() {
+			if typeHasPointers(subType) {
+				return true
+			}
 		}
+		return false
+	case llvm.ArrayTypeKind:
 		if typeHasPointers(t.ElementType()) {
 			return true
 		}

compiler/goroutine.go

@@ -47,16 +47,20 @@ func (b *builder) createGo(instr *ssa.Go) {
 		return
 	}
 
+	// Get all function parameters to pass to the goroutine.
 	var params []llvm.Value
+	for _, param := range instr.Call.Args {
+		params = append(params, b.expandFormalParam(b.getValue(param, getPos(instr)))...)
+	}
+
 	var prefix string
 	var funcPtr llvm.Value
 	var funcType llvm.Type
-	var context llvm.Value
 	hasContext := false
-	exported := false
 	if callee := instr.Call.StaticCallee(); callee != nil {
 		// Static callee is known. This makes it easier to start a new
 		// goroutine.
+		var context llvm.Value
 		switch value := instr.Call.Value.(type) {
 		case *ssa.Function:
 			// Goroutine call is regular function call. No context is necessary.
@@ -69,10 +73,10 @@ func (b *builder) createGo(instr *ssa.Go) {
 			panic("StaticCallee returned an unexpected value")
 		}
 		if !context.IsNil() {
+			params = append(params, context) // context parameter
 			hasContext = true
 		}
 		funcType, funcPtr = b.getFunction(callee)
-		exported = b.getFunctionInfo(callee).exported
 	} else if instr.Call.IsInvoke() {
 		// This is a method call on an interface value.
 		itf := b.getValue(instr.Call.Value, getPos(instr))
@@ -80,32 +84,23 @@ func (b *builder) createGo(instr *ssa.Go) {
 		itfValue := b.CreateExtractValue(itf, 1, "")
 		funcPtr = b.getInvokeFunction(&instr.Call)
 		funcType = funcPtr.GlobalValueType()
-		params = append(params, itfValue)
-		context = itfTypeCode
+		params = append([]llvm.Value{itfValue}, params...) // start with receiver
+		params = append(params, itfTypeCode)               // end with typecode
 	} else {
 		// This is a function pointer.
 		// At the moment, two extra params are passed to the newly started
 		// goroutine:
 		//   * The function context, for closures.
 		//   * The function pointer (for tasks).
+		var context llvm.Value
 		funcPtr, context = b.decodeFuncValue(b.getValue(instr.Call.Value, getPos(instr)))
 		funcType = b.getLLVMFunctionType(instr.Call.Value.Type().Underlying().(*types.Signature))
+		params = append(params, context, funcPtr)
 		hasContext = true
-		prefix = b.getFunctionInfo(b.fn).linkName
+		prefix = b.fn.RelString(nil)
 	}
 
-	for _, param := range instr.Call.Args {
-		params = append(params, b.getGoroutineCallArgument(param, exported)...)
-	}
-	if !context.IsNil() {
-		params = append(params, context)
-	}
-	if hasContext && instr.Call.StaticCallee() == nil {
-		params = append(params, funcPtr)
-	}
-	params = b.prependIndirectResult(instr.Call.Signature(), exported, params, "go.result")
-
-	paramBundle := b.emitPointerPack(params, instr.Pos())
+	paramBundle := b.emitPointerPack(params)
 	var stackSize llvm.Value
 	callee := b.createGoroutineStartWrapper(funcType, funcPtr, prefix, hasContext, false, instr.Pos())
 	if b.AutomaticStackSize {
@@ -127,15 +122,6 @@ func (b *builder) createGo(instr *ssa.Go) {
 	b.createCall(fnType, start, []llvm.Value{callee, paramBundle, stackSize, llvm.Undef(b.dataPtrType)}, "")
 }
 
-func (b *builder) getGoroutineCallArgument(value ssa.Value, exported bool) []llvm.Value {
-	typ := b.getLLVMType(value.Type())
-	arg := b.getCallArgument(value, exported)
-	if b.isIndirectParam(typ, exported) {
-		return []llvm.Value{b.copyToIndirectStorage(arg, typ, "go.param")}
-	}
-	return b.expandFormalParam(arg)
-}
-
 // Create an exported wrapper function for functions with the //go:wasmexport
 // pragma. This wrapper function is quite complex when the scheduler is enabled:
 // it needs to start a new goroutine each time the exported function is called.
@@ -153,7 +139,7 @@ func (b *builder) createWasmExport() {
 	// Declare the exported function.
 	paramTypes := b.llvmFnType.ParamTypes()
 	exportedFnType := llvm.FunctionType(b.llvmFnType.ReturnType(), paramTypes[:len(paramTypes)-1], false)
-	exportedFn := llvm.AddFunction(b.mod, b.getFunctionInfo(b.fn).linkName+suffix, exportedFnType)
+	exportedFn := llvm.AddFunction(b.mod, b.fn.RelString(nil)+suffix, exportedFnType)
 	b.addStandardAttributes(exportedFn)
 	llvmutil.AppendToGlobal(b.mod, "llvm.used", exportedFn)
 	exportedFn.AddFunctionAttr(b.ctx.CreateStringAttribute("wasm-export-name", b.info.wasmExport))
@@ -309,10 +295,10 @@ func (c *compilerContext) createGoroutineStartWrapper(fnType llvm.Type, fn llvm.
 	}
 	defer b.Dispose()
 
-	var exitGoroutine llvm.Value
-	var exitGoroutineType llvm.Type
+	var deadlock llvm.Value
+	var deadlockType llvm.Type
 	if c.Scheduler == "asyncify" {
-		exitGoroutineType, exitGoroutine = c.getFunction(c.program.ImportedPackage("runtime").Members["exitGoroutine"].(*ssa.Function))
+		deadlockType, deadlock = c.getFunction(c.program.ImportedPackage("runtime").Members["deadlock"].(*ssa.Function))
 	}
 
 	if !fn.IsAFunction().IsNil() {
@@ -377,7 +363,7 @@ func (c *compilerContext) createGoroutineStartWrapper(fnType llvm.Type, fn llvm.
 			b.CreateCall(fnType, fn, params, "")
 
 			if c.Scheduler == "asyncify" {
-				b.CreateCall(exitGoroutineType, exitGoroutine, []llvm.Value{
+				b.CreateCall(deadlockType, deadlock, []llvm.Value{
 					llvm.Undef(c.dataPtrType),
 				}, "")
 			}
@@ -428,7 +414,7 @@ func (c *compilerContext) createGoroutineStartWrapper(fnType llvm.Type, fn llvm.
 			// Extract parameters from the state object, and call the function
 			// that's being wrapped.
 			var callParams []llvm.Value
-			for i := range numParams {
+			for i := 0; i < numParams; i++ {
 				gep := b.CreateInBoundsGEP(stateStruct, statePtr, []llvm.Value{
 					llvm.ConstInt(b.ctx.Int32Type(), 0, false),
 					llvm.ConstInt(b.ctx.Int32Type(), uint64(i), false),
@@ -528,13 +514,14 @@ func (c *compilerContext) createGoroutineStartWrapper(fnType llvm.Type, fn llvm.
 		b.CreateCall(fnType, fnPtr, params, "")
 
 		if c.Scheduler == "asyncify" {
-			b.CreateCall(exitGoroutineType, exitGoroutine, []llvm.Value{
+			b.CreateCall(deadlockType, deadlock, []llvm.Value{
 				llvm.Undef(c.dataPtrType),
 			}, "")
 		}
 	}
 
 	if c.Scheduler == "asyncify" {
+		// The goroutine was terminated via deadlock.
 		b.CreateUnreachable()
 	} else {
 		// Finish the function. Every basic block must end in a terminator, and

compiler/inlineasm.go

@@ -38,10 +38,10 @@ func (b *builder) createInlineAsm(args []ssa.Value) (llvm.Value, error) {
 // provided immediately. For example:
 //
 //	arm.AsmFull(
-//	    "str {value}, [{result}]",
+//	    "str {value}, {result}",
 //	    map[string]interface{}{
-//	        "value":  1,
-//	        "result": uintptr(unsafe.Pointer(&dest)),
+//	        "value":  1
+//	        "result": &dest,
 //	    })
 func (b *builder) createInlineAsmFull(instr *ssa.CallCommon) (llvm.Value, error) {
 	asmString := constant.StringVal(instr.Args[0].(*ssa.Const).Value)
@@ -146,14 +146,13 @@ func (b *builder) emitSVCall(args []ssa.Value, pos token.Pos) (llvm.Value, error
 	llvmArgs := []llvm.Value{}
 	argTypes := []llvm.Type{}
 	asm := "svc #" + strconv.FormatUint(num, 10)
-	var constraints strings.Builder
-	constraints.WriteString("={r0}")
+	constraints := "={r0}"
 	for i, arg := range args[1:] {
 		arg = arg.(*ssa.MakeInterface).X
 		if i == 0 {
-			constraints.WriteString(",0")
+			constraints += ",0"
 		} else {
-			constraints.WriteString(",{r" + strconv.Itoa(i) + "}")
+			constraints += ",{r" + strconv.Itoa(i) + "}"
 		}
 		llvmValue := b.getValue(arg, pos)
 		llvmArgs = append(llvmArgs, llvmValue)
@@ -162,9 +161,9 @@ func (b *builder) emitSVCall(args []ssa.Value, pos token.Pos) (llvm.Value, error
 	// Implement the ARM calling convention by marking r1-r3 as
 	// clobbered. r0 is used as an output register so doesn't have to be
 	// marked as clobbered.
-	constraints.WriteString(",~{r1},~{r2},~{r3}")
+	constraints += ",~{r1},~{r2},~{r3}"
 	fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
-	target := llvm.InlineAsm(fnType, asm, constraints.String(), true, false, 0, false)
+	target := llvm.InlineAsm(fnType, asm, constraints, true, false, 0, false)
 	return b.CreateCall(fnType, target, llvmArgs, ""), nil
 }
 
@@ -185,14 +184,13 @@ func (b *builder) emitSV64Call(args []ssa.Value, pos token.Pos) (llvm.Value, err
 	llvmArgs := []llvm.Value{}
 	argTypes := []llvm.Type{}
 	asm := "svc #" + strconv.FormatUint(num, 10)
-	var constraints strings.Builder
-	constraints.WriteString("={x0}")
+	constraints := "={x0}"
 	for i, arg := range args[1:] {
 		arg = arg.(*ssa.MakeInterface).X
 		if i == 0 {
-			constraints.WriteString(",0")
+			constraints += ",0"
 		} else {
-			constraints.WriteString(",{x" + strconv.Itoa(i) + "}")
+			constraints += ",{x" + strconv.Itoa(i) + "}"
 		}
 		llvmValue := b.getValue(arg, pos)
 		llvmArgs = append(llvmArgs, llvmValue)
@@ -201,9 +199,9 @@ func (b *builder) emitSV64Call(args []ssa.Value, pos token.Pos) (llvm.Value, err
 	// Implement the ARM64 calling convention by marking x1-x7 as
 	// clobbered. x0 is used as an output register so doesn't have to be
 	// marked as clobbered.
-	constraints.WriteString(",~{x1},~{x2},~{x3},~{x4},~{x5},~{x6},~{x7}")
+	constraints += ",~{x1},~{x2},~{x3},~{x4},~{x5},~{x6},~{x7}"
 	fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
-	target := llvm.InlineAsm(fnType, asm, constraints.String(), true, false, 0, false)
+	target := llvm.InlineAsm(fnType, asm, constraints, true, false, 0, false)
 	return b.CreateCall(fnType, target, llvmArgs, ""), nil
 }
 
@@ -251,15 +249,3 @@ func (b *builder) emitCSROperation(call *ssa.CallCommon) (llvm.Value, error) {
 		return llvm.Value{}, b.makeError(call.Pos(), "unknown CSR operation: "+name)
 	}
 }
-
-// Implement runtime/interrupt.Checkpoint.Save. It needs to be implemented
-// directly at the call site. If it isn't implemented directly at the call site
-// (but instead through a function call), it might result in an overwritten
-// stack in the non-jump return case.
-func (b *builder) createInterruptCheckpoint(ptr ssa.Value) llvm.Value {
-	addr := b.getValue(ptr, ptr.Pos())
-	b.createNilCheck(ptr, addr, "deref")
-	stackPointer := b.readStackPointer()
-	b.CreateStore(stackPointer, addr)
-	return b.createCheckpoint(addr)
-}

compiler/intrinsics.go

@@ -7,7 +7,6 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/tinygo-org/tinygo/compiler/llvmutil"
 	"tinygo.org/x/go-llvm"
 )
 
@@ -28,8 +27,6 @@ func (b *builder) defineIntrinsicFunction() {
 		b.createStackSaveImpl()
 	case name == "runtime.KeepAlive":
 		b.createKeepAliveImpl()
-	case name == "machine.keepAliveNoEscape":
-		b.createMachineKeepAliveImpl()
 	case strings.HasPrefix(name, "runtime/volatile.Load"):
 		b.createVolatileLoad()
 	case strings.HasPrefix(name, "runtime/volatile.Store"):
@@ -51,24 +48,19 @@ func (b *builder) defineIntrinsicFunction() {
 // and will otherwise be lowered to regular libc memcpy/memmove calls.
 func (b *builder) createMemoryCopyImpl() {
 	b.createFunctionStart(true)
-	params := b.fn.Params[0:3]
-	b.createMemCopy(
-		b.fn.Name(),
-		b.getValue(params[0], getPos(b.fn)),
-		b.getValue(params[1], getPos(b.fn)),
-		b.getValue(params[2], getPos(b.fn)),
-	)
-	b.CreateRetVoid()
-}
-
-func (b *builder) createMemCopy(kind string, dst, src, len llvm.Value) llvm.Value {
-	fnName := "llvm." + kind + ".p0.p0.i" + strconv.Itoa(b.uintptrType.IntTypeWidth())
+	fnName := "llvm." + b.fn.Name() + ".p0.p0.i" + strconv.Itoa(b.uintptrType.IntTypeWidth())
 	llvmFn := b.mod.NamedFunction(fnName)
 	if llvmFn.IsNil() {
 		fnType := llvm.FunctionType(b.ctx.VoidType(), []llvm.Type{b.dataPtrType, b.dataPtrType, b.uintptrType, b.ctx.Int1Type()}, false)
 		llvmFn = llvm.AddFunction(b.mod, fnName, fnType)
 	}
-	return b.CreateCall(llvmFn.GlobalValueType(), llvmFn, []llvm.Value{dst, src, len, llvm.ConstInt(b.ctx.Int1Type(), 0, false)}, "")
+	var params []llvm.Value
+	for _, param := range b.fn.Params {
+		params = append(params, b.getValue(param, getPos(b.fn)))
+	}
+	params = append(params, llvm.ConstInt(b.ctx.Int1Type(), 0, false))
+	b.CreateCall(llvmFn.GlobalValueType(), llvmFn, params, "")
+	b.CreateRetVoid()
 }
 
 // createMemoryZeroImpl creates calls to llvm.memset.* to zero a block of
@@ -129,60 +121,13 @@ func (b *builder) createKeepAliveImpl() {
 	b.CreateRetVoid()
 }
 
-// createAbiEscapeImpl implements the generic internal/abi.Escape function. It
-// currently only supports pointer types.
-func (b *builder) createAbiEscapeImpl() {
-	b.createFunctionStart(true)
-
-	// The first parameter is assumed to be a pointer. This is checked at the
-	// call site of createAbiEscapeImpl.
-	pointerValue := b.getValue(b.fn.Params[0], getPos(b.fn))
-
-	// 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.dataPtrType, []llvm.Type{b.dataPtrType}, false)
-	asmFn := llvm.InlineAsm(asmType, "", "=r,0", true, false, 0, false)
-	result := b.createCall(asmType, asmFn, []llvm.Value{pointerValue}, "")
-
-	b.CreateRet(result)
-}
-
-// Implement machine.keepAliveNoEscape, which makes sure the compiler keeps the
-// pointer parameter alive until this point (for GC).
-func (b *builder) createMachineKeepAliveImpl() {
-	b.createFunctionStart(true)
-	pointerValue := b.getValue(b.fn.Params[0], getPos(b.fn))
-
-	// See createKeepAliveImpl for details.
-	asmType := llvm.FunctionType(b.ctx.VoidType(), []llvm.Type{b.dataPtrType}, 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.Acos":  "llvm.acos.f64",
-	"math.Asin":  "llvm.asin.f64",
-	"math.Atan":  "llvm.atan.f64",
-	"math.Atan2": "llvm.atan2.f64",
 	"math.Ceil":  "llvm.ceil.f64",
-	"math.Cos":   "llvm.cos.f64",
-	"math.Cosh":  "llvm.cosh.f64",
 	"math.Exp":   "llvm.exp.f64",
 	"math.Exp2":  "llvm.exp2.f64",
 	"math.Floor": "llvm.floor.f64",
 	"math.Log":   "llvm.log.f64",
-	"math.Sin":   "llvm.sin.f64",
-	"math.Sinh":  "llvm.sinh.f64",
 	"math.Sqrt":  "llvm.sqrt.f64",
-	"math.Tan":   "llvm.tan.f64",
-	"math.Tanh":  "llvm.tanh.f64",
 	"math.Trunc": "llvm.trunc.f64",
 }
 
@@ -196,40 +141,18 @@ var mathToLLVMMapping = map[string]string{
 // float32(math.Sqrt(float64(v))) to a 32-bit floating point operation, which is
 // beneficial on architectures where 64-bit floating point operations are (much)
 // more expensive than 32-bit ones.
-func (b *builder) defineMathOp() bool {
-	llvmName, ok := mathToLLVMMapping[b.fn.RelString(nil)]
-	if !ok {
-		return false
-	}
-	if strings.HasSuffix(b.Triple, "-wasi") || llvmutil.Version() < 19 {
-		// We don't have a real libc for wasip2. Until that is fixed, we need to
-		// limit math intrinsics on WASI to a subset supported natively in
-		// WebAssembly.
-		// Also, since we don't know the specific libc we will target, disallow
-		// these for all WASI targets.
-		//
-		// We also need to limit ourselves to LLVM 19 and above for the extended
-		// set of math intrinsics, see:
-		// https://discourse.llvm.org/t/rfc-all-the-math-intrinsics/78294
-		switch b.fn.Name() {
-		case "Ceil", "Exp", "Exp2", "Floor", "Log", "Sqrt", "Trunc":
-		default:
-			return false
-		}
-	}
+func (b *builder) defineMathOp() {
 	b.createFunctionStart(true)
+	llvmName := mathToLLVMMapping[b.fn.RelString(nil)]
+	if llvmName == "" {
+		panic("unreachable: unknown math operation") // sanity check
+	}
 	llvmFn := b.mod.NamedFunction(llvmName)
 	if llvmFn.IsNil() {
 		// The intrinsic doesn't exist yet, so declare it.
-		var llvmType llvm.Type
-		switch b.fn.Name() {
-		case "Atan2":
-			// double atan2(double %y, double %x)
-			llvmType = llvm.FunctionType(b.ctx.DoubleType(), []llvm.Type{b.ctx.DoubleType(), b.ctx.DoubleType()}, false)
-		default:
-			// double foo(double %x)
-			llvmType = llvm.FunctionType(b.ctx.DoubleType(), []llvm.Type{b.ctx.DoubleType()}, false)
-		}
+		// At the moment, all supported intrinsics have the form "double
+		// foo(double %x)" so we can hardcode the signature here.
+		llvmType := llvm.FunctionType(b.ctx.DoubleType(), []llvm.Type{b.ctx.DoubleType()}, false)
 		llvmFn = llvm.AddFunction(b.mod, llvmName, llvmType)
 	}
 	// Create a call to the intrinsic.
@@ -239,24 +162,6 @@ func (b *builder) defineMathOp() bool {
 	}
 	result := b.CreateCall(llvmFn.GlobalValueType(), llvmFn, args, "")
 	b.CreateRet(result)
-	return true
-}
-
-func (b *builder) defineCryptoIntrinsic() bool {
-	if b.fn.Pkg.Pkg.Path() != "crypto/internal/constanttime" {
-		return false
-	}
-
-	switch b.fn.Name() {
-	case "boolToUint8":
-		b.createFunctionStart(true)
-		param := b.getValue(b.fn.Params[0], b.fn.Pos())
-		result := b.CreateZExt(param, b.ctx.Int8Type(), "")
-		b.CreateRet(result)
-		return true
-	}
-
-	return false
 }
 
 // Implement most math/bits functions.

compiler/llvm.go

@@ -1,10 +1,10 @@
 package compiler
 
 import (
-	"encoding/binary"
 	"fmt"
 	"go/token"
 	"go/types"
+	"math/big"
 	"strings"
 
 	"github.com/tinygo-org/tinygo/compileopts"
@@ -54,7 +54,7 @@ func (b *builder) emitLifetimeEnd(ptr, size llvm.Value) {
 // pointer value directly. It returns the pointer with the packed data.
 // If the values are all constants, they are be stored in a constant global and
 // deduplicated.
-func (b *builder) emitPointerPack(values []llvm.Value, pos token.Pos) llvm.Value {
+func (b *builder) emitPointerPack(values []llvm.Value) llvm.Value {
 	valueTypes := make([]llvm.Type, len(values))
 	for i, value := range values {
 		valueTypes[i] = value.Type()
@@ -128,9 +128,14 @@ func (b *builder) emitPointerPack(values []llvm.Value, pos token.Pos) llvm.Value
 
 		// Packed data is bigger than a pointer, so allocate it on the heap.
 		sizeValue := llvm.ConstInt(b.uintptrType, size, false)
-		layoutValue := b.createObjectLayout(packedType, pos)
 		align := b.targetData.ABITypeAlignment(packedType)
-		packedAlloc := b.createAlloc(sizeValue, layoutValue, align, "")
+		alloc := b.mod.NamedFunction("runtime.alloc")
+		packedAlloc := b.CreateCall(alloc.GlobalValueType(), alloc, []llvm.Value{
+			sizeValue,
+			llvm.ConstNull(b.dataPtrType),
+			llvm.Undef(b.dataPtrType), // unused context parameter
+		}, "")
+		packedAlloc.AddCallSiteAttribute(0, b.ctx.CreateEnumAttribute(llvm.AttributeKindID("align"), uint64(align)))
 		if b.NeedsStackObjects {
 			b.trackPointer(packedAlloc)
 		}
@@ -207,7 +212,7 @@ func (c *compilerContext) makeGlobalArray(buf []byte, name string, elementType l
 	globalType := llvm.ArrayType(elementType, len(buf))
 	global := llvm.AddGlobal(c.mod, globalType, name)
 	value := llvm.Undef(globalType)
-	for i := range buf {
+	for i := 0; i < len(buf); i++ {
 		ch := uint64(buf[i])
 		value = c.builder.CreateInsertValue(value, llvm.ConstInt(elementType, ch, false), i, "")
 	}
@@ -226,12 +231,6 @@ func (c *compilerContext) makeGlobalArray(buf []byte, name string, elementType l
 //
 // For details on what's in this value, see src/runtime/gc_precise.go.
 func (c *compilerContext) createObjectLayout(t llvm.Type, pos token.Pos) llvm.Value {
-	if !typeHasPointers(t) {
-		// There are no pointers in this type, so we can simplify the layout.
-		layout := (uint64(1) << 1) | 1
-		return llvm.ConstIntToPtr(llvm.ConstInt(c.uintptrType, layout, false), c.dataPtrType)
-	}
-
 	// Use the element type for arrays. This works even for nested arrays.
 	for {
 		kind := t.TypeKind()
@@ -249,29 +248,54 @@ func (c *compilerContext) createObjectLayout(t llvm.Type, pos token.Pos) llvm.Va
 		break
 	}
 
-	// Create the pointer bitmap.
+	// Do a few checks to see whether we need to generate any object layout
+	// information at all.
 	objectSizeBytes := c.targetData.TypeAllocSize(t)
-	pointerAlignment := uint64(c.targetData.PrefTypeAlignment(c.dataPtrType))
-	bitmapLen := objectSizeBytes / pointerAlignment
-	bitmapBytes := (bitmapLen + 7) / 8
-	bitmap := make([]byte, bitmapBytes, max(bitmapBytes, 8))
-	c.buildPointerBitmap(bitmap, pointerAlignment, pos, t, 0)
-
-	// Try to encode the layout inline.
 	pointerSize := c.targetData.TypeAllocSize(c.dataPtrType)
-	pointerBits := pointerSize * 8
-	if bitmapLen < pointerBits {
-		rawMask := binary.LittleEndian.Uint64(bitmap[0:8])
-		layout := rawMask*pointerBits + bitmapLen
-		layout <<= 1
-		layout |= 1
+	pointerAlignment := c.targetData.PrefTypeAlignment(c.dataPtrType)
+	if objectSizeBytes < pointerSize {
+		// Too small to contain a pointer.
+		layout := (uint64(1) << 1) | 1
+		return llvm.ConstIntToPtr(llvm.ConstInt(c.uintptrType, layout, false), c.dataPtrType)
+	}
+	bitmap := c.getPointerBitmap(t, pos)
+	if bitmap.BitLen() == 0 {
+		// There are no pointers in this type, so we can simplify the layout.
+		// TODO: this can be done in many other cases, e.g. when allocating an
+		// array (like [4][]byte, which repeats a slice 4 times).
+		layout := (uint64(1) << 1) | 1
+		return llvm.ConstIntToPtr(llvm.ConstInt(c.uintptrType, layout, false), c.dataPtrType)
+	}
+	if objectSizeBytes%uint64(pointerAlignment) != 0 {
+		// This shouldn't happen except for packed structs, which aren't
+		// currently used.
+		c.addError(pos, "internal error: unexpected object size for object with pointer field")
+		return llvm.ConstNull(c.dataPtrType)
+	}
+	objectSizeWords := objectSizeBytes / uint64(pointerAlignment)
 
-		// Check if the layout fits.
-		layout &= 1<<pointerBits - 1
-		if (layout>>1)/pointerBits == rawMask {
-			// No set bits were shifted off.
-			return llvm.ConstIntToPtr(llvm.ConstInt(c.uintptrType, layout, false), c.dataPtrType)
-		}
+	pointerBits := pointerSize * 8
+	var sizeFieldBits uint64
+	switch pointerBits {
+	case 16:
+		sizeFieldBits = 4
+	case 32:
+		sizeFieldBits = 5
+	case 64:
+		sizeFieldBits = 6
+	default:
+		panic("unknown pointer size")
+	}
+	layoutFieldBits := pointerBits - 1 - sizeFieldBits
+
+	// Try to emit the value as an inline integer. This is possible in most
+	// cases.
+	if objectSizeWords < layoutFieldBits {
+		// If it can be stored directly in the pointer value, do so.
+		// The runtime knows that if the least significant bit of the pointer is
+		// set, the pointer contains the value itself.
+		layout := bitmap.Uint64()<<(sizeFieldBits+1) | (objectSizeWords << 1) | 1
+		return llvm.ConstIntToPtr(llvm.ConstInt(c.uintptrType, layout, false), c.dataPtrType)
 	}
 
 	// Unfortunately, the object layout is too big to fit in a pointer-sized
@@ -279,24 +303,25 @@ func (c *compilerContext) createObjectLayout(t llvm.Type, pos token.Pos) llvm.Va
 
 	// Try first whether the global already exists. All objects with a
 	// particular name have the same type, so this is possible.
-	globalName := "runtime/gc.layout:" + fmt.Sprintf("%d-%0*x", bitmapLen, (bitmapLen+15)/16, bitmap)
+	globalName := "runtime/gc.layout:" + fmt.Sprintf("%d-%0*x", objectSizeWords, (objectSizeWords+15)/16, bitmap)
 	global := c.mod.NamedGlobal(globalName)
 	if !global.IsNil() {
 		return global
 	}
 
 	// Create the global initializer.
-	bitmapByteValues := make([]llvm.Value, bitmapBytes)
-	i8 := c.ctx.Int8Type()
-	for i, b := range bitmap {
-		bitmapByteValues[i] = llvm.ConstInt(i8, uint64(b), false)
+	bitmapBytes := make([]byte, int(objectSizeWords+7)/8)
+	bitmap.FillBytes(bitmapBytes)
+	reverseBytes(bitmapBytes) // big-endian to little-endian
+	var bitmapByteValues []llvm.Value
+	for _, b := range bitmapBytes {
+		bitmapByteValues = append(bitmapByteValues, llvm.ConstInt(c.ctx.Int8Type(), uint64(b), false))
 	}
 	initializer := c.ctx.ConstStruct([]llvm.Value{
-		llvm.ConstInt(c.uintptrType, bitmapLen, false),
-		llvm.ConstArray(i8, bitmapByteValues),
+		llvm.ConstInt(c.uintptrType, objectSizeWords, false),
+		llvm.ConstArray(c.ctx.Int8Type(), bitmapByteValues),
 	}, false)
 
-	// Create the actual global.
 	global = llvm.AddGlobal(c.mod, initializer.Type(), globalName)
 	global.SetInitializer(initializer)
 	global.SetUnnamedAddr(true)
@@ -304,7 +329,6 @@ func (c *compilerContext) createObjectLayout(t llvm.Type, pos token.Pos) llvm.Va
 	global.SetLinkage(llvm.LinkOnceODRLinkage)
 	if c.targetData.PrefTypeAlignment(c.uintptrType) < 2 {
 		// AVR doesn't have alignment by default.
-		// The lowest bit must be unset to distinguish this from an inline layout.
 		global.SetAlignment(2)
 	}
 	if c.Debug && pos != token.NoPos {
@@ -336,71 +360,59 @@ func (c *compilerContext) createObjectLayout(t llvm.Type, pos token.Pos) llvm.Va
 	return global
 }
 
-// buildPointerBitmap scans the given LLVM type for pointers and sets bits in a
-// bitmap at the word offset that contains a pointer. This scan is recursive.
-func (c *compilerContext) buildPointerBitmap(
-	dst []byte,
-	ptrAlign uint64,
-	pos token.Pos,
-	t llvm.Type,
-	offset uint64,
-) {
-	switch t.TypeKind() {
+// getPointerBitmap scans the given LLVM type for pointers and sets bits in a
+// bigint at the word offset that contains a pointer. This scan is recursive.
+func (c *compilerContext) getPointerBitmap(typ llvm.Type, pos token.Pos) *big.Int {
+	alignment := c.targetData.PrefTypeAlignment(c.dataPtrType)
+	switch typ.TypeKind() {
 	case llvm.IntegerTypeKind, llvm.FloatTypeKind, llvm.DoubleTypeKind:
-		// These types do not contain pointers.
-
+		return big.NewInt(0)
 	case llvm.PointerTypeKind:
-		// Set the corresponding position in the bitmap.
-		dst[offset/8] |= 1 << (offset % 8)
-
+		return big.NewInt(1)
 	case llvm.StructTypeKind:
-		// Recurse over struct elements.
-		for i, et := range t.StructElementTypes() {
-			eo := c.targetData.ElementOffset(t, i)
-			if eo%uint64(ptrAlign) != 0 {
-				if typeHasPointers(et) {
-					// This error will let the compilation fail, but by continuing
-					// the error can still easily be shown.
-					c.addError(pos, "internal error: allocated struct contains unaligned pointer")
-				}
+		ptrs := big.NewInt(0)
+		if typ.StructName() == "runtime.funcValue" {
+			// Hack: the type runtime.funcValue contains an 'id' field which is
+			// of type uintptr, but before the LowerFuncValues pass it actually
+			// contains a pointer (ptrtoint) to a global. This trips up the
+			// interp package. Therefore, make the id field a pointer for now.
+			typ = c.ctx.StructType([]llvm.Type{c.dataPtrType, c.dataPtrType}, false)
+		}
+		for i, subtyp := range typ.StructElementTypes() {
+			subptrs := c.getPointerBitmap(subtyp, pos)
+			if subptrs.BitLen() == 0 {
 				continue
 			}
-			c.buildPointerBitmap(
-				dst,
-				ptrAlign,
-				pos,
-				et,
-				offset+(eo/ptrAlign),
-			)
-		}
-
-	case llvm.ArrayTypeKind:
-		// Recurse over array elements.
-		len := t.ArrayLength()
-		if len <= 0 {
-			return
-		}
-		et := t.ElementType()
-		elementSize := c.targetData.TypeAllocSize(et)
-		if elementSize%ptrAlign != 0 {
-			if typeHasPointers(et) {
-				// This error will let the compilation fail (but continues so that
-				// other errors can be shown).
-				c.addError(pos, "internal error: allocated array contains unaligned pointer")
+			offset := c.targetData.ElementOffset(typ, i)
+			if offset%uint64(alignment) != 0 {
+				// This error will let the compilation fail, but by continuing
+				// the error can still easily be shown.
+				c.addError(pos, "internal error: allocated struct contains unaligned pointer")
+				continue
 			}
-			return
+			subptrs.Lsh(subptrs, uint(offset)/uint(alignment))
+			ptrs.Or(ptrs, subptrs)
 		}
-		elementSize /= ptrAlign
-		for i := range len {
-			c.buildPointerBitmap(
-				dst,
-				ptrAlign,
-				pos,
-				et,
-				offset+uint64(i)*elementSize,
-			)
+		return ptrs
+	case llvm.ArrayTypeKind:
+		subtyp := typ.ElementType()
+		subptrs := c.getPointerBitmap(subtyp, pos)
+		ptrs := big.NewInt(0)
+		if subptrs.BitLen() == 0 {
+			return ptrs
 		}
-
+		elementSize := c.targetData.TypeAllocSize(subtyp)
+		if elementSize%uint64(alignment) != 0 {
+			// This error will let the compilation fail (but continues so that
+			// other errors can be shown).
+			c.addError(pos, "internal error: allocated array contains unaligned pointer")
+			return ptrs
+		}
+		for i := 0; i < typ.ArrayLength(); i++ {
+			ptrs.Lsh(ptrs, uint(elementSize)/uint(alignment))
+			ptrs.Or(ptrs, subptrs)
+		}
+		return ptrs
 	default:
 		// Should not happen.
 		panic("unknown LLVM type")
@@ -418,7 +430,7 @@ func (c *compilerContext) archFamily() string {
 // features string is not one for an ARM architecture.
 func (c *compilerContext) isThumb() bool {
 	var isThumb, isNotThumb bool
-	for feature := range strings.SplitSeq(c.Features, ",") {
+	for _, feature := range strings.Split(c.Features, ",") {
 		if feature == "+thumb-mode" {
 			isThumb = true
 		}
@@ -447,21 +459,6 @@ func (b *builder) readStackPointer() llvm.Value {
 	return b.CreateCall(stacksave.GlobalValueType(), stacksave, nil, "")
 }
 
-// writeStackPointer emits a LLVM intrinsic call that updates the current stack
-// pointer.
-func (b *builder) writeStackPointer(sp llvm.Value) {
-	name := "llvm.stackrestore.p0"
-	if llvmutil.Version() < 18 {
-		name = "llvm.stackrestore" // backwards compatibility with LLVM 17 and below
-	}
-	stackrestore := b.mod.NamedFunction(name)
-	if stackrestore.IsNil() {
-		fnType := llvm.FunctionType(b.ctx.VoidType(), []llvm.Type{b.dataPtrType}, false)
-		stackrestore = llvm.AddFunction(b.mod, name, fnType)
-	}
-	b.CreateCall(stackrestore.GlobalValueType(), stackrestore, []llvm.Value{sp}, "")
-}
-
 // createZExtOrTrunc lets the input value fit in the output type bits, by zero
 // extending or truncating the integer.
 func (b *builder) createZExtOrTrunc(value llvm.Value, t llvm.Type) llvm.Value {

compiler/llvmutil/llvm.go

@@ -44,7 +44,7 @@ func CreateTemporaryAlloca(builder llvm.Builder, mod llvm.Module, t llvm.Type, n
 	alloca = CreateEntryBlockAlloca(builder, t, name)
 	size = llvm.ConstInt(ctx.Int64Type(), targetData.TypeAllocSize(t), false)
 	fnType, fn := getLifetimeStartFunc(mod)
-	builder.CreateCall(fnType, fn, lifetimeCallArgs(size, alloca), "")
+	builder.CreateCall(fnType, fn, []llvm.Value{size, alloca}, "")
 	return
 }
 
@@ -58,14 +58,14 @@ func CreateInstructionAlloca(builder llvm.Builder, mod llvm.Module, t llvm.Type,
 	builder.SetInsertPointBefore(inst)
 	size := llvm.ConstInt(ctx.Int64Type(), targetData.TypeAllocSize(t), false)
 	fnType, fn := getLifetimeStartFunc(mod)
-	builder.CreateCall(fnType, fn, lifetimeCallArgs(size, alloca), "")
+	builder.CreateCall(fnType, fn, []llvm.Value{size, alloca}, "")
 	if next := llvm.NextInstruction(inst); !next.IsNil() {
 		builder.SetInsertPointBefore(next)
 	} else {
 		builder.SetInsertPointAtEnd(inst.InstructionParent())
 	}
 	fnType, fn = getLifetimeEndFunc(mod)
-	builder.CreateCall(fnType, fn, lifetimeCallArgs(size, alloca), "")
+	builder.CreateCall(fnType, fn, []llvm.Value{size, alloca}, "")
 	return alloca
 }
 
@@ -74,27 +74,7 @@ func CreateInstructionAlloca(builder llvm.Builder, mod llvm.Module, t llvm.Type,
 // createTemporaryAlloca.
 func EmitLifetimeEnd(builder llvm.Builder, mod llvm.Module, ptr, size llvm.Value) {
 	fnType, fn := getLifetimeEndFunc(mod)
-	builder.CreateCall(fnType, fn, lifetimeCallArgs(size, ptr), "")
-}
-
-// lifetimeCallArgs returns the arguments to pass to a call of the
-// llvm.lifetime.start/end intrinsics. LLVM 22 dropped the (redundant,
-// already required to match the alloca size) i64 size argument, so the
-// intrinsic now only takes the pointer.
-func lifetimeCallArgs(size, ptr llvm.Value) []llvm.Value {
-	if Version() >= 22 {
-		return []llvm.Value{ptr}
-	}
-	return []llvm.Value{size, ptr}
-}
-
-// lifetimeFuncType returns the function type of the llvm.lifetime.start/end
-// intrinsics, which lost their i64 size parameter in LLVM 22.
-func lifetimeFuncType(ctx llvm.Context, ptrType llvm.Type) llvm.Type {
-	if Version() >= 22 {
-		return llvm.FunctionType(ctx.VoidType(), []llvm.Type{ptrType}, false)
-	}
-	return llvm.FunctionType(ctx.VoidType(), []llvm.Type{ctx.Int64Type(), ptrType}, false)
+	builder.CreateCall(fnType, fn, []llvm.Value{size, ptr}, "")
 }
 
 // getLifetimeStartFunc returns the llvm.lifetime.start intrinsic and creates it
@@ -104,7 +84,7 @@ func getLifetimeStartFunc(mod llvm.Module) (llvm.Type, llvm.Value) {
 	fn := mod.NamedFunction(fnName)
 	ctx := mod.Context()
 	ptrType := llvm.PointerType(ctx.Int8Type(), 0)
-	fnType := lifetimeFuncType(ctx, ptrType)
+	fnType := llvm.FunctionType(ctx.VoidType(), []llvm.Type{ctx.Int64Type(), ptrType}, false)
 	if fn.IsNil() {
 		fn = llvm.AddFunction(mod, fnName, fnType)
 	}
@@ -118,7 +98,7 @@ func getLifetimeEndFunc(mod llvm.Module) (llvm.Type, llvm.Value) {
 	fn := mod.NamedFunction(fnName)
 	ctx := mod.Context()
 	ptrType := llvm.PointerType(ctx.Int8Type(), 0)
-	fnType := lifetimeFuncType(ctx, ptrType)
+	fnType := llvm.FunctionType(ctx.VoidType(), []llvm.Type{ctx.Int64Type(), ptrType}, false)
 	if fn.IsNil() {
 		fn = llvm.AddFunction(mod, fnName, fnType)
 	}
@@ -238,37 +218,7 @@ func Version() int {
 	return major
 }
 
-// NoCaptureAttrName returns the name of the LLVM attribute kind that marks a
-// pointer parameter as guaranteed not to escape by capture.
-//
-// LLVM 21 removed the old boolean 'nocapture' enum attribute in favor of the
-// more expressive 'captures' int attribute, where 'captures(none)' (encoded
-// as the value 0) is the equivalent of the old 'nocapture'. LLVM 20 supports
-// both, but its own optimizer still emits 'nocapture', so the cutoff for
-// reading/writing the new name is LLVM 21.
-func NoCaptureAttrName() string {
-	if Version() >= 21 {
-		return "captures"
-	}
-	return "nocapture"
-}
-
-// IsNoCapture reports whether attr (looked up using the kind returned by
-// NoCaptureAttrName) indicates that the pointer it is attached to does not
-// escape by capture. It returns false for a nil attribute.
-func IsNoCapture(attr llvm.Attribute) bool {
-	if attr.IsNil() {
-		return false
-	}
-	if Version() >= 21 {
-		// captures(none) is encoded as the value 0; any other value permits
-		// some form of capture.
-		return attr.GetEnumValue() == 0
-	}
-	return true
-}
-
-// ByteOrder returns the byte order for the given target triple. Most targets are little
+// Return the byte order for the given target triple. Most targets are little
 // endian, but for example MIPS can be big-endian.
 func ByteOrder(target string) binary.ByteOrder {
 	if strings.HasPrefix(target, "mips-") {

compiler/map.go

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

compiler/sizes.go

@@ -29,7 +29,8 @@ func (s *stdSizes) Alignof(T types.Type) int64 {
 		// is the largest of the values unsafe.Alignof(x.f) for each
 		// field f of x, but at least 1."
 		max := int64(1)
-		for f := range t.Fields() {
+		for i := 0; i < t.NumFields(); i++ {
+			f := t.Field(i)
 			if a := s.Alignof(f.Type()); a > max {
 				max = a
 			}

compiler/symbol.go

@@ -8,7 +8,6 @@ import (
 	"go/ast"
 	"go/token"
 	"go/types"
-	"slices"
 	"strconv"
 	"strings"
 
@@ -35,7 +34,6 @@ type functionInfo struct {
 	interrupt     bool       // go:interrupt
 	nobounds      bool       // go:nobounds
 	noescape      bool       // go:noescape
-	noheap        bool       // go:noheap
 	variadic      bool       // go:variadic (CGo only)
 	inline        inlineType // go:inline
 }
@@ -79,27 +77,24 @@ func (c *compilerContext) getFunction(fn *ssa.Function) (llvm.Type, llvm.Value)
 		return llvmFn.GlobalValueType(), llvmFn
 	}
 
-	retType, indirectResult := c.hasIndirectResult(fn.Signature)
-	if info.exported {
-		indirectResult = false
+	var retType llvm.Type
+	if fn.Signature.Results() == nil {
+		retType = c.ctx.VoidType()
+	} else if fn.Signature.Results().Len() == 1 {
+		retType = c.getLLVMType(fn.Signature.Results().At(0).Type())
+	} else {
+		results := make([]llvm.Type, 0, fn.Signature.Results().Len())
+		for i := 0; i < fn.Signature.Results().Len(); i++ {
+			results = append(results, c.getLLVMType(fn.Signature.Results().At(i).Type()))
+		}
+		retType = c.ctx.StructType(results, false)
 	}
 
 	var paramInfos []paramInfo
-	if indirectResult {
-		paramInfos = append(paramInfos, paramInfo{
-			llvmType: c.dataPtrType,
-			name:     "return",
-			elemSize: c.targetData.TypeAllocSize(retType),
-		})
-		retType = c.ctx.VoidType()
-	}
 	for _, param := range getParams(fn.Signature) {
 		paramType := c.getLLVMType(param.Type())
-		if info.exported {
-			paramInfos = append(paramInfos, c.expandDirectFormalParamType(paramType, param.Name(), param.Type())...)
-		} else {
-			paramInfos = append(paramInfos, c.expandFormalParamType(paramType, param.Name(), param.Type())...)
-		}
+		paramFragmentInfos := c.expandFormalParamType(paramType, param.Name(), param.Type())
+		paramInfos = append(paramInfos, paramFragmentInfos...)
 	}
 
 	// Add an extra parameter as the function context. This context is used in
@@ -109,20 +104,12 @@ func (c *compilerContext) getFunction(fn *ssa.Function) (llvm.Type, llvm.Value)
 	}
 
 	var paramTypes []llvm.Type
-	hasIndirectABI := indirectResult
 	for _, info := range paramInfos {
 		paramTypes = append(paramTypes, info.llvmType)
-		hasIndirectABI = hasIndirectABI || info.flags&paramIsIndirect != 0
 	}
 
 	fnType := llvm.FunctionType(retType, paramTypes, info.variadic)
 	llvmFn = llvm.AddFunction(c.mod, info.linkName, fnType)
-	if hasIndirectABI {
-		// Argument promotion only rewrites functions whose uses are all direct
-		// calls. Keep an address use so LLVM cannot reconstruct the large
-		// aggregate signature that this ABI exists to avoid.
-		llvmutil.AppendToGlobal(c.mod, "llvm.used", llvmFn)
-	}
 	if strings.HasPrefix(c.Triple, "wasm") {
 		// C functions without prototypes like this:
 		//   void foo();
@@ -152,14 +139,9 @@ func (c *compilerContext) getFunction(fn *ssa.Function) (llvm.Type, llvm.Value)
 			// not.
 			// (It may be safe to add the nocapture parameter to the context
 			// parameter, but I'd like to stay on the safe side here).
-			nocapture := c.ctx.CreateEnumAttribute(llvm.AttributeKindID(llvmutil.NoCaptureAttrName()), 0)
+			nocapture := c.ctx.CreateEnumAttribute(llvm.AttributeKindID("nocapture"), 0)
 			llvmFn.AddAttributeAtIndex(i+1, nocapture)
 		}
-		if paramInfo.flags&paramIsReadonly != 0 && paramInfo.llvmType.TypeKind() == llvm.PointerTypeKind {
-			// Readonly pointer parameters (like strings) benefit from being marked as readonly.
-			readonly := c.ctx.CreateEnumAttribute(llvm.AttributeKindID("readonly"), 0)
-			llvmFn.AddAttributeAtIndex(i+1, readonly)
-		}
 	}
 
 	// Set a number of function or parameter attributes, depending on the
@@ -171,10 +153,8 @@ func (c *compilerContext) getFunction(fn *ssa.Function) (llvm.Type, llvm.Value)
 		// Mark it as noreturn so LLVM can optimize away code.
 		llvmFn.AddFunctionAttr(c.ctx.CreateEnumAttribute(llvm.AttributeKindID("noreturn"), 0))
 	case "internal/abi.NoEscape":
-		llvmFn.AddAttributeAtIndex(1, c.ctx.CreateEnumAttribute(llvm.AttributeKindID(llvmutil.NoCaptureAttrName()), 0))
-	case "machine.keepAliveNoEscape", "machine.unsafeNoEscape":
-		llvmFn.AddAttributeAtIndex(1, c.ctx.CreateEnumAttribute(llvm.AttributeKindID(llvmutil.NoCaptureAttrName()), 0))
-	case "runtime.alloc", "runtime.alloc_noheap", "runtime.alloc_zero":
+		llvmFn.AddAttributeAtIndex(1, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("nocapture"), 0))
+	case "runtime.alloc":
 		// Tell the optimizer that runtime.alloc is an allocator, meaning that it
 		// returns values that are never null and never alias to an existing value.
 		for _, attrName := range []string{"noalias", "nonnull"} {
@@ -195,44 +175,25 @@ func (c *compilerContext) getFunction(fn *ssa.Function) (llvm.Type, llvm.Value)
 	case "runtime.sliceAppend":
 		// Appending a slice will only read the to-be-appended slice, it won't
 		// be modified.
-		llvmFn.AddAttributeAtIndex(2, c.ctx.CreateEnumAttribute(llvm.AttributeKindID(llvmutil.NoCaptureAttrName()), 0))
+		llvmFn.AddAttributeAtIndex(2, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("nocapture"), 0))
 		llvmFn.AddAttributeAtIndex(2, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("readonly"), 0))
+	case "runtime.sliceCopy":
+		// Copying a slice won't capture any of the parameters.
+		llvmFn.AddAttributeAtIndex(1, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("writeonly"), 0))
+		llvmFn.AddAttributeAtIndex(1, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("nocapture"), 0))
+		llvmFn.AddAttributeAtIndex(2, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("readonly"), 0))
+		llvmFn.AddAttributeAtIndex(2, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("nocapture"), 0))
 	case "runtime.stringFromBytes":
-		llvmFn.AddAttributeAtIndex(1, c.ctx.CreateEnumAttribute(llvm.AttributeKindID(llvmutil.NoCaptureAttrName()), 0))
+		llvmFn.AddAttributeAtIndex(1, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("nocapture"), 0))
 		llvmFn.AddAttributeAtIndex(1, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("readonly"), 0))
 	case "runtime.stringFromRunes":
-		llvmFn.AddAttributeAtIndex(1, c.ctx.CreateEnumAttribute(llvm.AttributeKindID(llvmutil.NoCaptureAttrName()), 0))
+		llvmFn.AddAttributeAtIndex(1, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("nocapture"), 0))
 		llvmFn.AddAttributeAtIndex(1, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("readonly"), 0))
-	case "runtime.hashmapSet":
-		// The key (param 2) and value (param 3) pointers are only read via
-		// memcpy/hash/equal and are never captured. The indirect calls
-		// through m.keyHash and m.keyEqual function pointers prevent LLVM's
-		// functionattrs pass from inferring this automatically.
-		llvmFn.AddAttributeAtIndex(2, c.ctx.CreateEnumAttribute(llvm.AttributeKindID(llvmutil.NoCaptureAttrName()), 0))
-		llvmFn.AddAttributeAtIndex(3, c.ctx.CreateEnumAttribute(llvm.AttributeKindID(llvmutil.NoCaptureAttrName()), 0))
-	case "runtime.hashmapGet":
-		// The key (param 2) is read-only and never captured.
-		// The value (param 3) is written to (receives the result) but never captured.
-		llvmFn.AddAttributeAtIndex(2, c.ctx.CreateEnumAttribute(llvm.AttributeKindID(llvmutil.NoCaptureAttrName()), 0))
-		llvmFn.AddAttributeAtIndex(3, c.ctx.CreateEnumAttribute(llvm.AttributeKindID(llvmutil.NoCaptureAttrName()), 0))
-	case "runtime.hashmapDelete":
-		// The key (param 2) is read-only and never captured.
-		llvmFn.AddAttributeAtIndex(2, c.ctx.CreateEnumAttribute(llvm.AttributeKindID(llvmutil.NoCaptureAttrName()), 0))
-	case "runtime.hashmapGenericSet":
-		// Same as hashmapBinarySet: key (param 2) and value (param 3) are
-		// not captured.
-		llvmFn.AddAttributeAtIndex(2, c.ctx.CreateEnumAttribute(llvm.AttributeKindID(llvmutil.NoCaptureAttrName()), 0))
-		llvmFn.AddAttributeAtIndex(3, c.ctx.CreateEnumAttribute(llvm.AttributeKindID(llvmutil.NoCaptureAttrName()), 0))
-	case "runtime.hashmapGenericGet":
-		llvmFn.AddAttributeAtIndex(2, c.ctx.CreateEnumAttribute(llvm.AttributeKindID(llvmutil.NoCaptureAttrName()), 0))
-		llvmFn.AddAttributeAtIndex(3, c.ctx.CreateEnumAttribute(llvm.AttributeKindID(llvmutil.NoCaptureAttrName()), 0))
-	case "runtime.hashmapGenericDelete":
-		llvmFn.AddAttributeAtIndex(2, c.ctx.CreateEnumAttribute(llvm.AttributeKindID(llvmutil.NoCaptureAttrName()), 0))
 	case "runtime.trackPointer":
 		// This function is necessary for tracking pointers on the stack in a
 		// portable way (see gc_stack_portable.go). Indicate to the optimizer
 		// that the only thing we'll do is read the pointer.
-		llvmFn.AddAttributeAtIndex(1, c.ctx.CreateEnumAttribute(llvm.AttributeKindID(llvmutil.NoCaptureAttrName()), 0))
+		llvmFn.AddAttributeAtIndex(1, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("nocapture"), 0))
 		llvmFn.AddAttributeAtIndex(1, c.ctx.CreateEnumAttribute(llvm.AttributeKindID("readonly"), 0))
 	case "__mulsi3", "__divmodsi4", "__udivmodsi4":
 		if strings.Split(c.Triple, "-")[0] == "avr" {
@@ -247,12 +208,6 @@ func (c *compilerContext) getFunction(fn *ssa.Function) (llvm.Type, llvm.Value)
 			// > circumstances, and should not be exposed to source languages.
 			llvmutil.AppendToGlobal(c.mod, "llvm.compiler.used", llvmFn)
 		}
-	case "GetModuleHandleExA", "GetProcAddress", "GetSystemInfo", "GetSystemTimeAsFileTime", "LoadLibraryExW", "QueryPerformanceCounter", "QueryPerformanceFrequency", "QueryUnbiasedInterruptTime", "SetEnvironmentVariableA", "Sleep", "SystemFunction036", "VirtualAlloc":
-		// On Windows we need to use a special calling convention for some
-		// external calls.
-		if c.GOOS == "windows" && c.GOARCH == "386" {
-			llvmFn.SetFunctionCallConv(llvm.X86StdcallCallConv)
-		}
 	}
 
 	// External/exported functions may not retain pointer values.
@@ -267,7 +222,7 @@ func (c *compilerContext) getFunction(fn *ssa.Function) (llvm.Type, llvm.Value)
 
 			llvmFn.AddFunctionAttr(c.ctx.CreateStringAttribute("wasm-import-name", info.wasmName))
 		}
-		nocaptureKind := llvm.AttributeKindID(llvmutil.NoCaptureAttrName())
+		nocaptureKind := llvm.AttributeKindID("nocapture")
 		nocapture := c.ctx.CreateEnumAttribute(nocaptureKind, 0)
 		for i, typ := range paramTypes {
 			if typ.TypeKind() == llvm.PointerTypeKind {
@@ -292,23 +247,6 @@ func (c *compilerContext) maybeCreateSyntheticFunction(fn *ssa.Function, llvmFn
 	// The exception is the package initializer, which does appear in the
 	// *ssa.Package members and so shouldn't be created here.
 	if fn.Synthetic != "" && fn.Synthetic != "package initializer" && fn.Synthetic != "generic function" && fn.Synthetic != "range-over-func yield" {
-		if origin := fn.Origin(); origin != nil && origin.RelString(nil) == "internal/abi.Escape" {
-			// This is a special implementation or internal/abi.Escape, which
-			// can only really be implemented in the compiler.
-			// For simplicity we'll only implement pointer parameters for now.
-			if _, ok := fn.Params[0].Type().Underlying().(*types.Pointer); ok {
-				irbuilder := c.ctx.NewBuilder()
-				defer irbuilder.Dispose()
-				b := newBuilder(c, irbuilder, fn)
-				b.createAbiEscapeImpl()
-				llvmFn.SetLinkage(llvm.LinkOnceODRLinkage)
-				llvmFn.SetUnnamedAddr(true)
-			}
-			// If the parameter is not of a pointer type, it will be left
-			// unimplemented. This will result in a linker error if the function
-			// is really called, making it clear it needs to be implemented.
-			return
-		}
 		if len(fn.Blocks) == 0 {
 			c.addError(fn.Pos(), "missing function body")
 			return
@@ -331,7 +269,7 @@ func (c *compilerContext) getFunctionInfo(f *ssa.Function) functionInfo {
 	}
 	info := functionInfo{
 		// Pick the default linkName.
-		linkName: c.canonicalFunctionName(f),
+		linkName: f.RelString(nil),
 	}
 
 	// Check for a few runtime functions that are treated specially.
@@ -358,18 +296,6 @@ func (c *compilerContext) getFunctionInfo(f *ssa.Function) functionInfo {
 	return info
 }
 
-func (c *compilerContext) canonicalFunctionName(f *ssa.Function) string {
-	typeArgs := f.TypeArgs()
-	if len(typeArgs) == 0 {
-		return f.RelString(nil)
-	}
-	parts := make([]string, len(typeArgs))
-	for i, ta := range typeArgs {
-		parts[i], _ = c.getTypeCodeName(ta)
-	}
-	return f.Origin().RelString(nil) + "[" + strings.Join(parts, ",") + "]"
-}
-
 // parsePragmas is used by getFunctionInfo to parse function pragmas such as
 // //export or //go:noinline.
 func (c *compilerContext) parsePragmas(info *functionInfo, f *ssa.Function) {
@@ -396,51 +322,6 @@ func (c *compilerContext) parsePragmas(info *functionInfo, f *ssa.Function) {
 		}
 	}
 
-	// Also scan file-level //go:linkname directives. These appear as
-	// free-standing comments in *ast.File.Comments (not attached to any
-	// declaration), and are used by modern golang.org/x/sys/unix and others.
-	// Function-attached directives (above) take precedence — we only add
-	// file-level ones if no doc-comment linkname was found for this function.
-	//
-	// TODO: the hasUnsafeImport gate enforced downstream (see the
-	// //go:linkname case below) is package-level. gc enforces it per
-	// file, on the file containing the directive. For file-level
-	// linknames this is more important than for function-attached ones,
-	// because the directive can live in a file separate from the
-	// function. A stricter implementation would check whether the file
-	// returned by fileForFunc imports "unsafe", not whether any file in
-	// the package does.
-	hasFunctionLinkname := false
-	for _, comment := range pragmas {
-		if strings.HasPrefix(comment.Text, "//go:linkname ") {
-			parts := strings.Fields(comment.Text)
-			if len(parts) == 3 && parts[1] == f.Name() {
-				hasFunctionLinkname = true
-				break
-			}
-		}
-	}
-	if !hasFunctionLinkname {
-		if file := c.fileForFunc(f); file != nil {
-			for _, group := range file.Comments {
-				// Skip the function's own doc comment — already handled above.
-				if decl, ok := syntax.(*ast.FuncDecl); ok && group == decl.Doc {
-					continue
-				}
-				for _, comment := range group.List {
-					if !strings.HasPrefix(comment.Text, "//go:linkname ") {
-						continue
-					}
-					parts := strings.Fields(comment.Text)
-					if len(parts) != 3 || parts[1] != f.Name() {
-						continue
-					}
-					pragmas = append(pragmas, comment)
-				}
-			}
-		}
-	}
-
 	// Parse each pragma.
 	for _, comment := range pragmas {
 		parts := strings.Fields(comment.Text)
@@ -458,7 +339,7 @@ func (c *compilerContext) parsePragmas(info *functionInfo, f *ssa.Function) {
 			info.wasmName = info.linkName
 			info.exported = true
 		case "//go:interrupt":
-			if slices.Contains(f.Pkg.Pkg.Imports(), types.Unsafe) {
+			if hasUnsafeImport(f.Pkg.Pkg) {
 				info.interrupt = true
 			}
 		case "//go:wasm-module":
@@ -512,7 +393,7 @@ func (c *compilerContext) parsePragmas(info *functionInfo, f *ssa.Function) {
 			info.inline = inlineHint
 		case "//go:noinline":
 			info.inline = inlineNone
-		case "//go:linkname", "//go:linknamestd":
+		case "//go:linkname":
 			if len(parts) != 3 || parts[1] != f.Name() {
 				continue
 			}
@@ -520,14 +401,14 @@ func (c *compilerContext) parsePragmas(info *functionInfo, f *ssa.Function) {
 			// This is a slightly looser requirement than what gc uses: gc
 			// requires the file to import "unsafe", not the package as a
 			// whole.
-			if slices.Contains(f.Pkg.Pkg.Imports(), types.Unsafe) {
+			if hasUnsafeImport(f.Pkg.Pkg) {
 				info.linkName = parts[2]
 			}
 		case "//go:section":
 			// Only enable go:section when the package imports "unsafe".
 			// go:section also implies go:noinline since inlining could
 			// move the code to a different section than that requested.
-			if len(parts) == 2 && slices.Contains(f.Pkg.Pkg.Imports(), types.Unsafe) {
+			if len(parts) == 2 && hasUnsafeImport(f.Pkg.Pkg) {
 				info.section = parts[1]
 				info.inline = inlineNone
 			}
@@ -536,7 +417,7 @@ func (c *compilerContext) parsePragmas(info *functionInfo, f *ssa.Function) {
 			// runtime functions.
 			// This is somewhat dangerous and thus only imported in packages
 			// that import unsafe.
-			if slices.Contains(f.Pkg.Pkg.Imports(), types.Unsafe) {
+			if hasUnsafeImport(f.Pkg.Pkg) {
 				info.nobounds = true
 			}
 		case "//go:noescape":
@@ -546,24 +427,18 @@ func (c *compilerContext) parsePragmas(info *functionInfo, f *ssa.Function) {
 			if len(f.Blocks) == 0 {
 				info.noescape = true
 			}
-		case "//go:noheap":
-			// Ensure this function does not allocate on the heap.
-			info.noheap = true
 		case "//go:variadic":
 			// The //go:variadic pragma is emitted by the CGo preprocessing
 			// pass for C variadic functions. This includes both explicit
 			// (with ...) and implicit (no parameters in signature)
 			// functions.
-			if strings.HasPrefix(f.Name(), "_Cgo_") {
-				// This prefix was created as a result of CGo preprocessing.
+			if strings.HasPrefix(f.Name(), "C.") {
+				// This prefix cannot naturally be created, it must have
+				// been created as a result of CGo preprocessing.
 				info.variadic = true
 			}
 		}
 	}
-
-	if c.Nobounds {
-		info.nobounds = true
-	}
 }
 
 // Check whether this function can be used in //go:wasmimport or
@@ -572,7 +447,7 @@ func (c *compilerContext) parsePragmas(info *functionInfo, f *ssa.Function) {
 // The list of allowed types is based on this proposal:
 // https://github.com/golang/go/issues/59149
 func (c *compilerContext) checkWasmImportExport(f *ssa.Function, pragma string) {
-	if c.pkg.Path() == "runtime" || c.pkg.Path() == "syscall/js" || c.pkg.Path() == "syscall" || c.pkg.Path() == "crypto/internal/sysrand" {
+	if c.pkg.Path() == "runtime" || c.pkg.Path() == "syscall/js" || c.pkg.Path() == "syscall" {
 		// The runtime is a special case. Allow all kinds of parameters
 		// (importantly, including pointers).
 		return
@@ -636,9 +511,9 @@ func (c *compilerContext) isValidWasmType(typ types.Type, site wasmSite) bool {
 				hasHostLayout = false // package structs added in go1.23
 			}
 		}
-		for field := range typ.Fields() {
-			ftyp := field.Type()
-			if types.Unalias(ftyp).String() == "structs.HostLayout" {
+		for i := 0; i < typ.NumFields(); i++ {
+			ftyp := typ.Field(i).Type()
+			if ftyp.String() == "structs.HostLayout" {
 				hasHostLayout = true
 				continue
 			}
@@ -669,8 +544,8 @@ func getParams(sig *types.Signature) []*types.Var {
 	if sig.Recv() != nil {
 		params = append(params, sig.Recv())
 	}
-	for v := range sig.Params().Variables() {
-		params = append(params, v)
+	for i := 0; i < sig.Params().Len(); i++ {
+		params = append(params, sig.Params().At(i))
 	}
 	return params
 }
@@ -729,40 +604,12 @@ func (c *compilerContext) addStandardAttributes(llvmFn llvm.Value) {
 // linkName is equal to .RelString(nil) on a global and extern is false, but for
 // some symbols this is different (due to //go:extern for example).
 type globalInfo struct {
-	linkName string // go:extern, go:linkname
+	linkName string // go:extern
 	extern   bool   // go:extern
 	align    int    // go:align
 	section  string // go:section
 }
 
-// fileForFunc returns the *ast.File that contains the declaration of f, or
-// nil if it cannot be determined. File-level pragmas are only consulted for
-// functions in the package currently being compiled — functions imported from
-// other packages have their file-level pragmas processed when those packages
-// are compiled.
-func (c *compilerContext) fileForFunc(f *ssa.Function) *ast.File {
-	if c.loaderPkg == nil || f.Pkg == nil || f.Pkg.Pkg != c.loaderPkg.Pkg {
-		return nil
-	}
-	syntax := f.Syntax()
-	if f.Origin() != nil {
-		syntax = f.Origin().Syntax()
-	}
-	if syntax == nil {
-		return nil
-	}
-	pos := syntax.Pos()
-	if !pos.IsValid() {
-		return nil
-	}
-	for _, file := range c.loaderPkg.Files {
-		if file.FileStart <= pos && pos < file.FileEnd {
-			return file
-		}
-	}
-	return nil
-}
-
 // loadASTComments loads comments on globals from the AST, for use later in the
 // program. In particular, they are required for //go:extern pragmas on globals.
 func (c *compilerContext) loadASTComments(pkg *loader.Package) {
@@ -801,7 +648,10 @@ func (c *compilerContext) getGlobal(g *ssa.Global) llvm.Value {
 		llvmGlobal = llvm.AddGlobal(c.mod, llvmType, info.linkName)
 
 		// Set alignment from the //go:align comment.
-		alignment := max(info.align, c.targetData.ABITypeAlignment(llvmType))
+		alignment := c.targetData.ABITypeAlignment(llvmType)
+		if info.align > alignment {
+			alignment = info.align
+		}
 		if alignment <= 0 || alignment&(alignment-1) != 0 {
 			// Check for power-of-two (or 0).
 			// See: https://stackoverflow.com/a/108360
@@ -839,14 +689,14 @@ func (c *compilerContext) getGlobalInfo(g *ssa.Global) globalInfo {
 	// Check for //go: pragmas, which may change the link name (among others).
 	doc := c.astComments[info.linkName]
 	if doc != nil {
-		info.parsePragmas(doc, c, g)
+		info.parsePragmas(doc)
 	}
 	return info
 }
 
 // Parse //go: pragma comments from the source. In particular, it parses the
-// //go:extern and //go:linkname pragmas on globals.
-func (info *globalInfo) parsePragmas(doc *ast.CommentGroup, c *compilerContext, g *ssa.Global) {
+// //go:extern pragma on globals.
+func (info *globalInfo) parsePragmas(doc *ast.CommentGroup) {
 	for _, comment := range doc.List {
 		if !strings.HasPrefix(comment.Text, "//go:") {
 			continue
@@ -867,17 +717,6 @@ func (info *globalInfo) parsePragmas(doc *ast.CommentGroup, c *compilerContext,
 			if len(parts) == 2 {
 				info.section = parts[1]
 			}
-		case "//go:linkname":
-			if len(parts) != 3 || parts[1] != g.Name() {
-				continue
-			}
-			// Only enable go:linkname when the package imports "unsafe".
-			// This is a slightly looser requirement than what gc uses: gc
-			// requires the file to import "unsafe", not the package as a
-			// whole.
-			if slices.Contains(g.Pkg.Pkg.Imports(), types.Unsafe) {
-				info.linkName = parts[2]
-			}
 		}
 	}
 }
@@ -891,3 +730,13 @@ func getAllMethods(prog *ssa.Program, typ types.Type) []*types.Selection {
 	}
 	return methods
 }
+
+// Return true if this package imports "unsafe", false otherwise.
+func hasUnsafeImport(pkg *types.Package) bool {
+	for _, imp := range pkg.Imports() {
+		if imp == types.Unsafe {
+			return true
+		}
+	}
+	return false
+}

compiler/syscall.go

@@ -26,25 +26,24 @@ func (b *builder) createRawSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		argTypes := []llvm.Type{b.uintptrType}
 		// Constraints will look something like:
 		//   "={rax},0,{rdi},{rsi},{rdx},{r10},{r8},{r9},~{rcx},~{r11}"
-		var constraints strings.Builder
-		constraints.WriteString("={rax},0")
+		constraints := "={rax},0"
 		for i, arg := range call.Args[1:] {
-			constraints.WriteString("," + [...]string{
+			constraints += "," + [...]string{
 				"{rdi}",
 				"{rsi}",
 				"{rdx}",
 				"{r10}",
 				"{r8}",
 				"{r9}",
-			}[i])
+			}[i]
 			llvmValue := b.getValue(arg, getPos(call))
 			args = append(args, llvmValue)
 			argTypes = append(argTypes, llvmValue.Type())
 		}
 		// rcx and r11 are clobbered by the syscall, so make sure they are not used
-		constraints.WriteString(",~{rcx},~{r11}")
+		constraints += ",~{rcx},~{r11}"
 		fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
-		target := llvm.InlineAsm(fnType, "syscall", constraints.String(), true, false, llvm.InlineAsmDialectIntel, false)
+		target := llvm.InlineAsm(fnType, "syscall", constraints, true, false, llvm.InlineAsmDialectIntel, false)
 		return b.CreateCall(fnType, target, args, ""), nil
 
 	case b.GOARCH == "386" && b.GOOS == "linux":
@@ -56,44 +55,34 @@ func (b *builder) createRawSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		argTypes := []llvm.Type{b.uintptrType}
 		// Constraints will look something like:
 		//   "={eax},0,{ebx},{ecx},{edx},{esi},{edi},{ebp}"
-		var constraints strings.Builder
-		constraints.WriteString("={eax},0")
+		constraints := "={eax},0"
 		for i, arg := range call.Args[1:] {
-			constraints.WriteString("," + [...]string{
+			constraints += "," + [...]string{
 				"{ebx}",
 				"{ecx}",
 				"{edx}",
 				"{esi}",
 				"{edi}",
 				"{ebp}",
-			}[i])
+			}[i]
 			llvmValue := b.getValue(arg, getPos(call))
 			args = append(args, llvmValue)
 			argTypes = append(argTypes, llvmValue.Type())
 		}
 		fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
-		target := llvm.InlineAsm(fnType, "int 0x80", constraints.String(), true, false, llvm.InlineAsmDialectIntel, false)
+		target := llvm.InlineAsm(fnType, "int 0x80", constraints, true, false, llvm.InlineAsmDialectIntel, false)
 		return b.CreateCall(fnType, target, args, ""), nil
 
 	case b.GOARCH == "arm" && b.GOOS == "linux":
-		if arch := b.archFamily(); arch != "arm" {
-			// Some targets pretend to be linux/arm for compatibility but aren't
-			// actually such a system. Make sure we emit an error instead of
-			// creating inline assembly that will fail to compile.
-			// See: https://github.com/tinygo-org/tinygo/issues/4959
-			return llvm.Value{}, b.makeError(call.Pos(), "system calls are not supported: target emulates a linux/arm system on "+arch)
-		}
-
 		// Implement the EABI system call convention for Linux.
 		// Source: syscall(2) man page.
 		args := []llvm.Value{}
 		argTypes := []llvm.Type{}
 		// Constraints will look something like:
 		//   ={r0},0,{r1},{r2},{r7},~{r3}
-		var constraints strings.Builder
-		constraints.WriteString("={r0}")
+		constraints := "={r0}"
 		for i, arg := range call.Args[1:] {
-			constraints.WriteString("," + [...]string{
+			constraints += "," + [...]string{
 				"0", // tie to output
 				"{r1}",
 				"{r2}",
@@ -101,20 +90,20 @@ func (b *builder) createRawSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 				"{r4}",
 				"{r5}",
 				"{r6}",
-			}[i])
+			}[i]
 			llvmValue := b.getValue(arg, getPos(call))
 			args = append(args, llvmValue)
 			argTypes = append(argTypes, llvmValue.Type())
 		}
 		args = append(args, num)
 		argTypes = append(argTypes, b.uintptrType)
-		constraints.WriteString(",{r7}") // syscall number
+		constraints += ",{r7}" // syscall number
 		for i := len(call.Args) - 1; i < 4; i++ {
 			// r0-r3 get clobbered after the syscall returns
-			constraints.WriteString(",~{r" + strconv.Itoa(i) + "}")
+			constraints += ",~{r" + strconv.Itoa(i) + "}"
 		}
 		fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
-		target := llvm.InlineAsm(fnType, "svc #0", constraints.String(), true, false, 0, false)
+		target := llvm.InlineAsm(fnType, "svc #0", constraints, true, false, 0, false)
 		return b.CreateCall(fnType, target, args, ""), nil
 
 	case b.GOARCH == "arm64" && b.GOOS == "linux":
@@ -123,32 +112,31 @@ func (b *builder) createRawSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		argTypes := []llvm.Type{}
 		// Constraints will look something like:
 		//   ={x0},0,{x1},{x2},{x8},~{x3},~{x4},~{x5},~{x6},~{x7},~{x16},~{x17}
-		var constraints strings.Builder
-		constraints.WriteString("={x0}")
+		constraints := "={x0}"
 		for i, arg := range call.Args[1:] {
-			constraints.WriteString("," + [...]string{
+			constraints += "," + [...]string{
 				"0", // tie to output
 				"{x1}",
 				"{x2}",
 				"{x3}",
 				"{x4}",
 				"{x5}",
-			}[i])
+			}[i]
 			llvmValue := b.getValue(arg, getPos(call))
 			args = append(args, llvmValue)
 			argTypes = append(argTypes, llvmValue.Type())
 		}
 		args = append(args, num)
 		argTypes = append(argTypes, b.uintptrType)
-		constraints.WriteString(",{x8}") // syscall number
+		constraints += ",{x8}" // syscall number
 		for i := len(call.Args) - 1; i < 8; i++ {
 			// x0-x7 may get clobbered during the syscall following the aarch64
 			// calling convention.
-			constraints.WriteString(",~{x" + strconv.Itoa(i) + "}")
+			constraints += ",~{x" + strconv.Itoa(i) + "}"
 		}
-		constraints.WriteString(",~{x16},~{x17}") // scratch registers
+		constraints += ",~{x16},~{x17}" // scratch registers
 		fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
-		target := llvm.InlineAsm(fnType, "svc #0", constraints.String(), true, false, 0, false)
+		target := llvm.InlineAsm(fnType, "svc #0", constraints, true, false, 0, false)
 		return b.CreateCall(fnType, target, args, ""), nil
 
 	case (b.GOARCH == "mips" || b.GOARCH == "mipsle") && b.GOOS == "linux":
@@ -167,8 +155,7 @@ func (b *builder) createRawSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		// faster and smaller code.
 		args := []llvm.Value{num}
 		argTypes := []llvm.Type{b.uintptrType}
-		var constraints strings.Builder
-		constraints.WriteString("={$2},={$7},0")
+		constraints := "={$2},={$7},0"
 		syscallParams := call.Args[1:]
 		if len(syscallParams) > 7 {
 			// There is one syscall that uses 7 parameters: sync_file_range.
@@ -177,7 +164,7 @@ func (b *builder) createRawSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 			syscallParams = syscallParams[:7]
 		}
 		for i, arg := range syscallParams {
-			constraints.WriteString("," + [...]string{
+			constraints += "," + [...]string{
 				"{$4}", // arg1
 				"{$5}", // arg2
 				"{$6}", // arg3
@@ -185,7 +172,7 @@ func (b *builder) createRawSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 				"r",    // arg5 on the stack
 				"r",    // arg6 on the stack
 				"r",    // arg7 on the stack
-			}[i])
+			}[i]
 			llvmValue := b.getValue(arg, getPos(call))
 			args = append(args, llvmValue)
 			argTypes = append(argTypes, llvmValue.Type())
@@ -226,10 +213,10 @@ func (b *builder) createRawSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 				"addu $$sp, $$sp, 32\n" +
 				".set at\n"
 		}
-		constraints.WriteString(",~{$3},~{$4},~{$5},~{$6},~{$8},~{$9},~{$10},~{$11},~{$12},~{$13},~{$14},~{$15},~{$24},~{$25},~{hi},~{lo},~{memory}")
+		constraints += ",~{$3},~{$4},~{$5},~{$6},~{$8},~{$9},~{$10},~{$11},~{$12},~{$13},~{$14},~{$15},~{$24},~{$25},~{hi},~{lo},~{memory}"
 		returnType := b.ctx.StructType([]llvm.Type{b.uintptrType, b.uintptrType}, false)
 		fnType := llvm.FunctionType(returnType, argTypes, false)
-		target := llvm.InlineAsm(fnType, asm, constraints.String(), true, true, 0, false)
+		target := llvm.InlineAsm(fnType, asm, constraints, true, true, 0, false)
 		call := b.CreateCall(fnType, target, args, "")
 		resultCode := b.CreateExtractValue(call, 0, "") // r2
 		errorFlag := b.CreateExtractValue(call, 1, "")  // r7
@@ -281,8 +268,6 @@ func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		// The signature looks like this:
 		//   func Syscall(trap, nargs, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
 
-		isI386 := strings.HasPrefix(b.Triple, "i386-")
-
 		// Prepare input values.
 		var paramTypes []llvm.Type
 		var params []llvm.Value
@@ -300,17 +285,11 @@ func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		if setLastError.IsNil() {
 			llvmType := llvm.FunctionType(b.ctx.VoidType(), []llvm.Type{b.ctx.Int32Type()}, false)
 			setLastError = llvm.AddFunction(b.mod, "SetLastError", llvmType)
-			if isI386 {
-				setLastError.SetFunctionCallConv(llvm.X86StdcallCallConv)
-			}
 		}
 		getLastError := b.mod.NamedFunction("GetLastError")
 		if getLastError.IsNil() {
 			llvmType := llvm.FunctionType(b.ctx.Int32Type(), nil, false)
 			getLastError = llvm.AddFunction(b.mod, "GetLastError", llvmType)
-			if isI386 {
-				getLastError.SetFunctionCallConv(llvm.X86StdcallCallConv)
-			}
 		}
 
 		// Now do the actual call. Pseudocode:
@@ -321,24 +300,9 @@ func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		// Note that SetLastError/GetLastError could be replaced with direct
 		// access to the thread control block, which is probably smaller and
 		// faster. The Go runtime does this in assembly.
-		// On windows/386, we also need to save/restore the stack pointer. I'm
-		// not entirely sure why this is needed, but without it these calls
-		// change the stack pointer leading to a crash soon after.
-		setLastErrorCall := b.CreateCall(setLastError.GlobalValueType(), setLastError, []llvm.Value{llvm.ConstNull(b.ctx.Int32Type())}, "")
-		var sp llvm.Value
-		if isI386 {
-			setLastErrorCall.SetInstructionCallConv(llvm.X86StdcallCallConv)
-			sp = b.readStackPointer()
-		}
+		b.CreateCall(setLastError.GlobalValueType(), setLastError, []llvm.Value{llvm.ConstNull(b.ctx.Int32Type())}, "")
 		syscallResult := b.CreateCall(llvmType, fnPtr, params, "")
-		if isI386 {
-			syscallResult.SetInstructionCallConv(llvm.X86StdcallCallConv)
-			b.writeStackPointer(sp)
-		}
 		errResult := b.CreateCall(getLastError.GlobalValueType(), getLastError, nil, "err")
-		if isI386 {
-			errResult.SetInstructionCallConv(llvm.X86StdcallCallConv)
-		}
 		if b.uintptrType != b.ctx.Int32Type() {
 			errResult = b.CreateZExt(errResult, b.uintptrType, "err.uintptr")
 		}
@@ -354,130 +318,6 @@ func (b *builder) createSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 	}
 }
 
-// createSyscalln emits instructions for the syscall.syscalln function on
-// Windows. This handles the variadic calling convention used in Go 1.26+:
-//
-//	func syscalln(fn, n uintptr, args ...uintptr) (r1, r2 uintptr, err Errno)
-//
-// The function generates a switch on n to dispatch to the correct fixed-argument
-// function pointer call with SetLastError(0)/GetLastError() wrapping.
-func (b *builder) createSyscalln(call *ssa.CallCommon) (llvm.Value, error) {
-	const maxArgs = 18 // Windows syscalls support up to 18 args
-
-	isI386 := strings.HasPrefix(b.Triple, "i386-")
-
-	// Get the function pointer (call.Args[0]) and n (call.Args[1]).
-	fn := b.getValue(call.Args[0], getPos(call))
-	fnPtr := b.CreateIntToPtr(fn, b.dataPtrType, "")
-	n := b.getValue(call.Args[1], getPos(call))
-
-	// Get the variadic args slice (call.Args[2]).
-	// In SSA, the variadic slice is the third argument.
-	var argsPtr llvm.Value
-	if len(call.Args) > 2 {
-		argsSlice := b.getValue(call.Args[2], getPos(call))
-		argsPtr = b.CreateExtractValue(argsSlice, 0, "args.data")
-	} else {
-		argsPtr = llvm.ConstNull(b.dataPtrType)
-	}
-
-	// Prepare SetLastError and GetLastError.
-	setLastError := b.mod.NamedFunction("SetLastError")
-	if setLastError.IsNil() {
-		llvmType := llvm.FunctionType(b.ctx.VoidType(), []llvm.Type{b.ctx.Int32Type()}, false)
-		setLastError = llvm.AddFunction(b.mod, "SetLastError", llvmType)
-		if isI386 {
-			setLastError.SetFunctionCallConv(llvm.X86StdcallCallConv)
-		}
-	}
-	getLastError := b.mod.NamedFunction("GetLastError")
-	if getLastError.IsNil() {
-		llvmType := llvm.FunctionType(b.ctx.Int32Type(), nil, false)
-		getLastError = llvm.AddFunction(b.mod, "GetLastError", llvmType)
-		if isI386 {
-			getLastError.SetFunctionCallConv(llvm.X86StdcallCallConv)
-		}
-	}
-
-	retType := b.ctx.StructType([]llvm.Type{b.uintptrType, b.uintptrType, b.uintptrType}, false)
-
-	// Create the merge block where all cases converge.
-	mergeBB := b.insertBasicBlock("syscalln.merge")
-
-	// Create the default (panic) block.
-	panicBB := b.insertBasicBlock("syscalln.panic")
-
-	// Create the switch on n.
-	sw := b.CreateSwitch(n, panicBB, maxArgs+1)
-
-	// We'll collect blocks and values for the PHI node.
-	var incomingVals []llvm.Value
-	var incomingBlocks []llvm.BasicBlock
-
-	// Generate a case for each arg count 0..maxArgs.
-	for i := 0; i <= maxArgs; i++ {
-		caseBB := b.insertBasicBlock("syscalln.case" + strconv.Itoa(i))
-		sw.AddCase(llvm.ConstInt(b.uintptrType, uint64(i), false), caseBB)
-		b.SetInsertPointAtEnd(caseBB)
-
-		// Load args[0] through args[i-1] from the slice data pointer.
-		var params []llvm.Value
-		var paramTypes []llvm.Type
-		for j := 0; j < i; j++ {
-			gep := b.CreateInBoundsGEP(b.uintptrType, argsPtr, []llvm.Value{
-				llvm.ConstInt(b.ctx.Int32Type(), uint64(j), false),
-			}, "")
-			arg := b.CreateLoad(b.uintptrType, gep, "")
-			params = append(params, arg)
-			paramTypes = append(paramTypes, b.uintptrType)
-		}
-
-		// SetLastError(0)
-		setCall := b.CreateCall(setLastError.GlobalValueType(), setLastError, []llvm.Value{llvm.ConstNull(b.ctx.Int32Type())}, "")
-		var sp llvm.Value
-		if isI386 {
-			setCall.SetInstructionCallConv(llvm.X86StdcallCallConv)
-			sp = b.readStackPointer()
-		}
-
-		// Call fn(args...)
-		fnType := llvm.FunctionType(b.uintptrType, paramTypes, false)
-		syscallResult := b.CreateCall(fnType, fnPtr, params, "")
-		if isI386 {
-			syscallResult.SetInstructionCallConv(llvm.X86StdcallCallConv)
-			b.writeStackPointer(sp)
-		}
-
-		// err = GetLastError()
-		errResult := b.CreateCall(getLastError.GlobalValueType(), getLastError, nil, "err")
-		if isI386 {
-			errResult.SetInstructionCallConv(llvm.X86StdcallCallConv)
-		}
-		if b.uintptrType != b.ctx.Int32Type() {
-			errResult = b.CreateZExt(errResult, b.uintptrType, "err.uintptr")
-		}
-
-		// Build {r1, 0, err}
-		result := llvm.ConstNull(retType)
-		result = b.CreateInsertValue(result, syscallResult, 0, "")
-		result = b.CreateInsertValue(result, errResult, 2, "")
-
-		incomingVals = append(incomingVals, result)
-		incomingBlocks = append(incomingBlocks, b.Builder.GetInsertBlock())
-		b.CreateBr(mergeBB)
-	}
-
-	// Panic block for n > maxArgs.
-	b.SetInsertPointAtEnd(panicBB)
-	b.CreateUnreachable()
-
-	// Merge block: PHI node to select the result.
-	b.SetInsertPointAtEnd(mergeBB)
-	phi := b.CreatePHI(retType, "syscalln.result")
-	phi.AddIncoming(incomingVals, incomingBlocks)
-	return phi, nil
-}
-
 // createRawSyscallNoError emits instructions for the Linux-specific
 // syscall.rawSyscallNoError function.
 func (b *builder) createRawSyscallNoError(call *ssa.CallCommon) (llvm.Value, error) {

compiler/testdata/basic.go

@@ -66,11 +66,6 @@ func complexSub(x, y complex64) complex64 {
 	return x - y
 }
 
-func shiftNested(x uint64) uint64 {
-	k := 3
-	return x >> (1 << k) // https://github.com/tinygo-org/tinygo/issues/5496
-}
-
 func complexMul(x, y complex64) complex64 {
 	return x * y
 }

compiler/testdata/basic.ll

@@ -1,6 +1,6 @@
 ; ModuleID = 'basic.go'
 source_filename = "basic.go"
-target datalayout = "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-i128:128-n32:64-S128-ni:1:10:20"
+target datalayout = "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-n32:64-S128-ni:1:10:20"
 target triple = "wasm32-unknown-wasi"
 
 %main.kv = type { float, i32, i32, i32 }
@@ -10,30 +10,33 @@ target triple = "wasm32-unknown-wasi"
 @main.a = hidden global { ptr, i32, i32 } zeroinitializer, align 4
 @main.b = hidden global [2 x ptr] zeroinitializer, align 4
 
-declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #0
+; Function Attrs: allockind("alloc,zeroed") allocsize(0)
+declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #0
+
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #1
 
 ; Function Attrs: nounwind
-define hidden void @main.init(ptr %context) unnamed_addr #1 {
+define hidden void @main.init(ptr %context) unnamed_addr #2 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.addInt(i32 %x, i32 %y, ptr %context) unnamed_addr #1 {
+define hidden i32 @main.addInt(i32 %x, i32 %y, ptr %context) unnamed_addr #2 {
 entry:
   %0 = add i32 %x, %y
   ret i32 %0
 }
 
 ; Function Attrs: nounwind
-define hidden i1 @main.equalInt(i32 %x, i32 %y, ptr %context) unnamed_addr #1 {
+define hidden i1 @main.equalInt(i32 %x, i32 %y, ptr %context) unnamed_addr #2 {
 entry:
   %0 = icmp eq i32 %x, %y
   ret i1 %0
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.divInt(i32 %x, i32 %y, ptr %context) unnamed_addr #1 {
+define hidden i32 @main.divInt(i32 %x, i32 %y, ptr %context) unnamed_addr #2 {
 entry:
   %0 = icmp eq i32 %y, 0
   br i1 %0, label %divbyzero.throw, label %divbyzero.next
@@ -47,14 +50,14 @@ divbyzero.next:                                   ; preds = %entry
   ret i32 %5
 
 divbyzero.throw:                                  ; preds = %entry
-  call void @runtime.divideByZeroPanic(ptr undef) #2
+  call void @runtime.divideByZeroPanic(ptr undef) #3
   unreachable
 }
 
-declare void @runtime.divideByZeroPanic(ptr) #0
+declare void @runtime.divideByZeroPanic(ptr) #1
 
 ; Function Attrs: nounwind
-define hidden i32 @main.divUint(i32 %x, i32 %y, ptr %context) unnamed_addr #1 {
+define hidden i32 @main.divUint(i32 %x, i32 %y, ptr %context) unnamed_addr #2 {
 entry:
   %0 = icmp eq i32 %y, 0
   br i1 %0, label %divbyzero.throw, label %divbyzero.next
@@ -64,12 +67,12 @@ divbyzero.next:                                   ; preds = %entry
   ret i32 %1
 
 divbyzero.throw:                                  ; preds = %entry
-  call void @runtime.divideByZeroPanic(ptr undef) #2
+  call void @runtime.divideByZeroPanic(ptr undef) #3
   unreachable
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.remInt(i32 %x, i32 %y, ptr %context) unnamed_addr #1 {
+define hidden i32 @main.remInt(i32 %x, i32 %y, ptr %context) unnamed_addr #2 {
 entry:
   %0 = icmp eq i32 %y, 0
   br i1 %0, label %divbyzero.throw, label %divbyzero.next
@@ -83,12 +86,12 @@ divbyzero.next:                                   ; preds = %entry
   ret i32 %5
 
 divbyzero.throw:                                  ; preds = %entry
-  call void @runtime.divideByZeroPanic(ptr undef) #2
+  call void @runtime.divideByZeroPanic(ptr undef) #3
   unreachable
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.remUint(i32 %x, i32 %y, ptr %context) unnamed_addr #1 {
+define hidden i32 @main.remUint(i32 %x, i32 %y, ptr %context) unnamed_addr #2 {
 entry:
   %0 = icmp eq i32 %y, 0
   br i1 %0, label %divbyzero.throw, label %divbyzero.next
@@ -98,66 +101,66 @@ divbyzero.next:                                   ; preds = %entry
   ret i32 %1
 
 divbyzero.throw:                                  ; preds = %entry
-  call void @runtime.divideByZeroPanic(ptr undef) #2
+  call void @runtime.divideByZeroPanic(ptr undef) #3
   unreachable
 }
 
 ; Function Attrs: nounwind
-define hidden i1 @main.floatEQ(float %x, float %y, ptr %context) unnamed_addr #1 {
+define hidden i1 @main.floatEQ(float %x, float %y, ptr %context) unnamed_addr #2 {
 entry:
   %0 = fcmp oeq float %x, %y
   ret i1 %0
 }
 
 ; Function Attrs: nounwind
-define hidden i1 @main.floatNE(float %x, float %y, ptr %context) unnamed_addr #1 {
+define hidden i1 @main.floatNE(float %x, float %y, ptr %context) unnamed_addr #2 {
 entry:
   %0 = fcmp une float %x, %y
   ret i1 %0
 }
 
 ; Function Attrs: nounwind
-define hidden i1 @main.floatLower(float %x, float %y, ptr %context) unnamed_addr #1 {
+define hidden i1 @main.floatLower(float %x, float %y, ptr %context) unnamed_addr #2 {
 entry:
   %0 = fcmp olt float %x, %y
   ret i1 %0
 }
 
 ; Function Attrs: nounwind
-define hidden i1 @main.floatLowerEqual(float %x, float %y, ptr %context) unnamed_addr #1 {
+define hidden i1 @main.floatLowerEqual(float %x, float %y, ptr %context) unnamed_addr #2 {
 entry:
   %0 = fcmp ole float %x, %y
   ret i1 %0
 }
 
 ; Function Attrs: nounwind
-define hidden i1 @main.floatGreater(float %x, float %y, ptr %context) unnamed_addr #1 {
+define hidden i1 @main.floatGreater(float %x, float %y, ptr %context) unnamed_addr #2 {
 entry:
   %0 = fcmp ogt float %x, %y
   ret i1 %0
 }
 
 ; Function Attrs: nounwind
-define hidden i1 @main.floatGreaterEqual(float %x, float %y, ptr %context) unnamed_addr #1 {
+define hidden i1 @main.floatGreaterEqual(float %x, float %y, ptr %context) unnamed_addr #2 {
 entry:
   %0 = fcmp oge float %x, %y
   ret i1 %0
 }
 
 ; Function Attrs: nounwind
-define hidden float @main.complexReal(float %x.r, float %x.i, ptr %context) unnamed_addr #1 {
+define hidden float @main.complexReal(float %x.r, float %x.i, ptr %context) unnamed_addr #2 {
 entry:
   ret float %x.r
 }
 
 ; Function Attrs: nounwind
-define hidden float @main.complexImag(float %x.r, float %x.i, ptr %context) unnamed_addr #1 {
+define hidden float @main.complexImag(float %x.r, float %x.i, ptr %context) unnamed_addr #2 {
 entry:
   ret float %x.i
 }
 
 ; Function Attrs: nounwind
-define hidden { float, float } @main.complexAdd(float %x.r, float %x.i, float %y.r, float %y.i, ptr %context) unnamed_addr #1 {
+define hidden { float, float } @main.complexAdd(float %x.r, float %x.i, float %y.r, float %y.i, ptr %context) unnamed_addr #2 {
 entry:
   %0 = fadd float %x.r, %y.r
   %1 = fadd float %x.i, %y.i
@@ -167,7 +170,7 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden { float, float } @main.complexSub(float %x.r, float %x.i, float %y.r, float %y.i, ptr %context) unnamed_addr #1 {
+define hidden { float, float } @main.complexSub(float %x.r, float %x.i, float %y.r, float %y.i, ptr %context) unnamed_addr #2 {
 entry:
   %0 = fsub float %x.r, %y.r
   %1 = fsub float %x.i, %y.i
@@ -177,14 +180,7 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden i64 @main.shiftNested(i64 %x, ptr %context) unnamed_addr #1 {
-entry:
-  %0 = lshr i64 %x, 8
-  ret i64 %0
-}
-
-; Function Attrs: nounwind
-define hidden { float, float } @main.complexMul(float %x.r, float %x.i, float %y.r, float %y.i, ptr %context) unnamed_addr #1 {
+define hidden { float, float } @main.complexMul(float %x.r, float %x.i, float %y.r, float %y.i, ptr %context) unnamed_addr #2 {
 entry:
   %0 = fmul float %x.r, %y.r
   %1 = fmul float %x.i, %y.i
@@ -198,18 +194,19 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.foo(ptr %context) unnamed_addr #1 {
+define hidden void @main.foo(ptr %context) unnamed_addr #2 {
 entry:
   call void @"main.foo$1"(%main.kv.0 zeroinitializer, ptr undef)
   ret void
 }
 
 ; Function Attrs: nounwind
-define internal void @"main.foo$1"(%main.kv.0 %b, ptr %context) unnamed_addr #1 {
+define internal void @"main.foo$1"(%main.kv.0 %b, ptr %context) unnamed_addr #2 {
 entry:
   ret void
 }
 
-attributes #0 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #1 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #2 = { nounwind }
+attributes #0 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+bulk-memory,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #1 = { "target-features"="+bulk-memory,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #2 = { nounwind "target-features"="+bulk-memory,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #3 = { nounwind }

compiler/testdata/channel.ll

@@ -1,92 +1,95 @@
 ; ModuleID = 'channel.go'
 source_filename = "channel.go"
-target datalayout = "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-i128:128-n32:64-S128-ni:1:10:20"
+target 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.channelOp = type { ptr, ptr, i32, ptr }
 %runtime.chanSelectState = type { ptr, ptr }
 
-declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #0
+; Function Attrs: allockind("alloc,zeroed") allocsize(0)
+declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #0
+
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #1
 
 ; Function Attrs: nounwind
-define hidden void @main.init(ptr %context) unnamed_addr #1 {
+define hidden void @main.init(ptr %context) unnamed_addr #2 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.chanIntSend(ptr dereferenceable_or_null(36) %ch, ptr %context) unnamed_addr #1 {
+define hidden void @main.chanIntSend(ptr dereferenceable_or_null(36) %ch, ptr %context) unnamed_addr #2 {
 entry:
   %chan.op = alloca %runtime.channelOp, align 8
   %chan.value = alloca i32, align 4
-  call void @llvm.lifetime.start.p0(ptr nonnull %chan.value)
+  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %chan.value)
   store i32 3, ptr %chan.value, align 4
-  call void @llvm.lifetime.start.p0(ptr nonnull %chan.op)
-  call void @runtime.chanSend(ptr %ch, ptr nonnull %chan.value, ptr nonnull %chan.op, ptr undef) #3
-  call void @llvm.lifetime.end.p0(ptr nonnull %chan.op)
-  call void @llvm.lifetime.end.p0(ptr nonnull %chan.value)
+  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %chan.op)
+  call void @runtime.chanSend(ptr %ch, ptr nonnull %chan.value, ptr nonnull %chan.op, ptr undef) #4
+  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %chan.op)
+  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %chan.value)
   ret void
 }
 
 ; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: readwrite)
-declare void @llvm.lifetime.start.p0(ptr nocapture) #2
+declare void @llvm.lifetime.start.p0(i64 immarg, ptr nocapture) #3
 
-declare void @runtime.chanSend(ptr dereferenceable_or_null(36), ptr, ptr dereferenceable_or_null(16), ptr) #0
+declare void @runtime.chanSend(ptr dereferenceable_or_null(36), ptr, ptr dereferenceable_or_null(16), ptr) #1
 
 ; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: readwrite)
-declare void @llvm.lifetime.end.p0(ptr nocapture) #2
+declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #3
 
 ; Function Attrs: nounwind
-define hidden void @main.chanIntRecv(ptr dereferenceable_or_null(36) %ch, ptr %context) unnamed_addr #1 {
+define hidden void @main.chanIntRecv(ptr dereferenceable_or_null(36) %ch, ptr %context) unnamed_addr #2 {
 entry:
   %chan.op = alloca %runtime.channelOp, align 8
   %chan.value = alloca i32, align 4
-  call void @llvm.lifetime.start.p0(ptr nonnull %chan.value)
-  call void @llvm.lifetime.start.p0(ptr nonnull %chan.op)
-  %0 = call i1 @runtime.chanRecv(ptr %ch, ptr nonnull %chan.value, ptr nonnull %chan.op, ptr undef) #3
-  call void @llvm.lifetime.end.p0(ptr nonnull %chan.value)
-  call void @llvm.lifetime.end.p0(ptr nonnull %chan.op)
+  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %chan.value)
+  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %chan.op)
+  %0 = call i1 @runtime.chanRecv(ptr %ch, ptr nonnull %chan.value, ptr nonnull %chan.op, ptr undef) #4
+  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %chan.value)
+  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %chan.op)
   ret void
 }
 
-declare i1 @runtime.chanRecv(ptr dereferenceable_or_null(36), ptr, ptr dereferenceable_or_null(16), ptr) #0
+declare i1 @runtime.chanRecv(ptr dereferenceable_or_null(36), ptr, ptr dereferenceable_or_null(16), ptr) #1
 
 ; Function Attrs: nounwind
-define hidden void @main.chanZeroSend(ptr dereferenceable_or_null(36) %ch, ptr %context) unnamed_addr #1 {
+define hidden void @main.chanZeroSend(ptr dereferenceable_or_null(36) %ch, ptr %context) unnamed_addr #2 {
 entry:
   %chan.op = alloca %runtime.channelOp, align 8
-  call void @llvm.lifetime.start.p0(ptr nonnull %chan.op)
-  call void @runtime.chanSend(ptr %ch, ptr null, ptr nonnull %chan.op, ptr undef) #3
-  call void @llvm.lifetime.end.p0(ptr nonnull %chan.op)
+  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %chan.op)
+  call void @runtime.chanSend(ptr %ch, ptr null, ptr nonnull %chan.op, ptr undef) #4
+  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %chan.op)
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.chanZeroRecv(ptr dereferenceable_or_null(36) %ch, ptr %context) unnamed_addr #1 {
+define hidden void @main.chanZeroRecv(ptr dereferenceable_or_null(36) %ch, ptr %context) unnamed_addr #2 {
 entry:
   %chan.op = alloca %runtime.channelOp, align 8
-  call void @llvm.lifetime.start.p0(ptr nonnull %chan.op)
-  %0 = call i1 @runtime.chanRecv(ptr %ch, ptr null, ptr nonnull %chan.op, ptr undef) #3
-  call void @llvm.lifetime.end.p0(ptr nonnull %chan.op)
+  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %chan.op)
+  %0 = call i1 @runtime.chanRecv(ptr %ch, ptr null, ptr nonnull %chan.op, ptr undef) #4
+  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %chan.op)
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.selectZeroRecv(ptr dereferenceable_or_null(36) %ch1, ptr dereferenceable_or_null(36) %ch2, ptr %context) unnamed_addr #1 {
+define hidden void @main.selectZeroRecv(ptr dereferenceable_or_null(36) %ch1, ptr dereferenceable_or_null(36) %ch2, ptr %context) unnamed_addr #2 {
 entry:
   %select.states.alloca = alloca [2 x %runtime.chanSelectState], align 8
   %select.send.value = alloca i32, align 4
   store i32 1, ptr %select.send.value, align 4
-  call void @llvm.lifetime.start.p0(ptr nonnull %select.states.alloca)
+  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %select.states.alloca)
   store ptr %ch1, ptr %select.states.alloca, align 4
-  %select.states.alloca.repack1 = getelementptr inbounds nuw i8, ptr %select.states.alloca, i32 4
+  %select.states.alloca.repack1 = getelementptr inbounds i8, ptr %select.states.alloca, i32 4
   store ptr %select.send.value, ptr %select.states.alloca.repack1, align 4
-  %0 = getelementptr inbounds nuw i8, ptr %select.states.alloca, i32 8
+  %0 = getelementptr inbounds i8, ptr %select.states.alloca, i32 8
   store ptr %ch2, ptr %0, align 4
-  %.repack3 = getelementptr inbounds nuw i8, ptr %select.states.alloca, i32 12
+  %.repack3 = getelementptr inbounds i8, ptr %select.states.alloca, i32 12
   store ptr null, ptr %.repack3, align 4
-  %select.result = call { i32, i1 } @runtime.chanSelect(ptr undef, ptr nonnull %select.states.alloca, i32 2, i32 2, ptr null, i32 0, i32 0, ptr undef) #3
-  call void @llvm.lifetime.end.p0(ptr nonnull %select.states.alloca)
+  %select.result = call { i32, i1 } @runtime.chanSelect(ptr undef, ptr nonnull %select.states.alloca, i32 2, i32 2, ptr null, i32 0, i32 0, ptr undef) #4
+  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %select.states.alloca)
   %1 = extractvalue { i32, i1 } %select.result, 0
   %2 = icmp eq i32 %1, 0
   br i1 %2, label %select.done, label %select.next
@@ -102,9 +105,10 @@ select.body:                                      ; preds = %select.next
   br label %select.done
 }
 
-declare { i32, i1 } @runtime.chanSelect(ptr, ptr, i32, i32, ptr, i32, i32, ptr) #0
+declare { i32, i1 } @runtime.chanSelect(ptr, ptr, i32, i32, ptr, i32, i32, ptr) #1
 
-attributes #0 = { "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #1 = { nounwind "target-features"="+bulk-memory,+bulk-memory-opt,+call-indirect-overlong,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
-attributes #2 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
-attributes #3 = { nounwind }
+attributes #0 = { allockind("alloc,zeroed") allocsize(0) "alloc-family"="runtime.alloc" "target-features"="+bulk-memory,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #1 = { "target-features"="+bulk-memory,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #2 = { nounwind "target-features"="+bulk-memory,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types" }
+attributes #3 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
+attributes #4 = { nounwind }