Added mstats fields

This was actually surprising once I got TinyGo to build on Windows 11
ARM64. All the changes are exactly what you'd expect for a new
architecture, there was no special weirdness just for arm64.

Actually getting TinyGo to build was kind of involved though. The very
short summary is: install arm64 versions of some pieces of software
(like golang, cmake) instead of installing them though choco. In
particular, use the llvm-mingw[1] toolchain instead of using standard
mingw.

[1]: https://github.com/mstorsjo/llvm-mingw/releases

.circleci/config.yml

@@ -6,18 +6,6 @@ commands:
       - run:
           name: "Pull submodules"
           command: git submodule update --init
-  install-xtensa-toolchain:
-    parameters:
-      variant:
-        type: string
-    steps:
-      - run:
-          name: "Install Xtensa toolchain"
-          command: |
-            curl -L https://github.com/espressif/crosstool-NG/releases/download/esp-2020r2/xtensa-esp32-elf-gcc8_2_0-esp-2020r2-<<parameters.variant>>.tar.gz -o xtensa-esp32-elf-gcc8_2_0-esp-2020r2-<<parameters.variant>>.tar.gz
-            sudo tar -C /usr/local -xf xtensa-esp32-elf-gcc8_2_0-esp-2020r2-<<parameters.variant>>.tar.gz
-            sudo ln -s /usr/local/xtensa-esp32-elf/bin/xtensa-esp32-elf-ld /usr/local/bin/xtensa-esp32-elf-ld
-            rm xtensa-esp32-elf-gcc8_2_0-esp-2020r2-<<parameters.variant>>.tar.gz
   llvm-source-linux:
     steps:
       - restore_cache:
@@ -75,8 +63,6 @@ commands:
                 clang-<<parameters.llvm>> \
                 libclang-<<parameters.llvm>>-dev \
                 lld-<<parameters.llvm>> \
-                gcc-avr \
-                avr-libc \
                 cmake \
                 ninja-build
       - hack-ninja-jobs
@@ -119,6 +105,13 @@ jobs:
       - test-linux:
           llvm: "14"
     resource_class: large
+  test-llvm15-go120:
+    docker:
+      - image: golang:1.20-rc-buster
+    steps:
+      - test-linux:
+          llvm: "15"
+    resource_class: large
 
 workflows:
   test-all:
@@ -126,3 +119,4 @@ workflows:
       # This tests our lowest supported versions of Go and LLVM, to make sure at
       # least the smoke tests still pass.
       - test-llvm14-go118
+      - test-llvm15-go120

.github/workflows/build-macos.yml

@@ -20,15 +20,8 @@ jobs:
         shell: bash
         run: |
           HOMEBREW_NO_AUTO_UPDATE=1 brew install qemu binaryen
-      - name: Install Xtensa toolchain
-        shell: bash
-        run: |
-          curl -L https://github.com/espressif/crosstool-NG/releases/download/esp-2020r2/xtensa-esp32-elf-gcc8_2_0-esp-2020r2-macos.tar.gz -o xtensa-esp32-elf-gcc8_2_0-esp-2020r2-macos.tar.gz
-          sudo tar -C /usr/local -xf xtensa-esp32-elf-gcc8_2_0-esp-2020r2-macos.tar.gz
-          sudo ln -s /usr/local/xtensa-esp32-elf/bin/xtensa-esp32-elf-ld /usr/local/bin/xtensa-esp32-elf-ld
-          rm xtensa-esp32-elf-gcc8_2_0-esp-2020r2-macos.tar.gz
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
         with:
           submodules: true
       - name: Install Go
@@ -40,7 +33,7 @@ jobs:
         uses: actions/cache@v3
         id: cache-llvm-source
         with:
-          key: llvm-source-14-macos-v1
+          key: llvm-source-15-macos-v2
           path: |
             llvm-project/clang/lib/Headers
             llvm-project/clang/include
@@ -54,7 +47,7 @@ jobs:
         uses: actions/cache@v3
         id: cache-llvm-build
         with:
-          key: llvm-build-14-macos-v1
+          key: llvm-build-15-macos-v2
           path: llvm-build
       - name: Build LLVM
         if: steps.cache-llvm-build.outputs.cache-hit != 'true'
@@ -100,7 +93,7 @@ jobs:
           path: build/tinygo.darwin-amd64.tar.gz
       - name: Smoke tests
         shell: bash
-        run: make smoketest TINYGO=$(PWD)/build/tinygo AVR=0
+        run: make smoketest TINYGO=$(PWD)/build/tinygo
   test-macos-homebrew:
     name: homebrew-install
     runs-on: macos-latest
@@ -108,7 +101,7 @@ jobs:
       - name: Install LLVM
         shell: bash
         run: |
-          HOMEBREW_NO_AUTO_UPDATE=1 brew install llvm@14
+          HOMEBREW_NO_AUTO_UPDATE=1 brew install llvm@15
       - name: Checkout
         uses: actions/checkout@v2
       - name: Install Go

.github/workflows/docker.yml

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

.github/workflows/linux.yml

@@ -29,7 +29,7 @@ jobs:
         # We're not on a multi-user machine, so this is safe.
         run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
         with:
           submodules: true
       - name: Cache Go
@@ -43,7 +43,7 @@ jobs:
         uses: actions/cache@v3
         id: cache-llvm-source
         with:
-          key: llvm-source-14-linux-alpine-v1
+          key: llvm-source-15-linux-alpine-v2
           path: |
             llvm-project/clang/lib/Headers
             llvm-project/clang/include
@@ -57,7 +57,7 @@ jobs:
         uses: actions/cache@v3
         id: cache-llvm-build
         with:
-          key: llvm-build-14-linux-alpine-v1
+          key: llvm-build-15-linux-alpine-v2
           path: llvm-build
       - name: Build LLVM
         if: steps.cache-llvm-build.outputs.cache-hit != 'true'
@@ -102,7 +102,7 @@ jobs:
           cp -p build/release.tar.gz /tmp/tinygo.linux-amd64.tar.gz
           cp -p build/release.deb    /tmp/tinygo_amd64.deb
       - name: Publish release artifact
-        uses: actions/upload-artifact@v2
+        uses: actions/upload-artifact@v3
         with:
           name: linux-amd64-double-zipped
           path: |
@@ -114,7 +114,7 @@ jobs:
     needs: build-linux
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
       - name: Install Go
         uses: actions/setup-go@v3
         with:
@@ -125,7 +125,7 @@ jobs:
           curl https://wasmtime.dev/install.sh -sSf | bash
           echo "$HOME/.wasmtime/bin" >> $GITHUB_PATH
       - name: Download release artifact
-        uses: actions/download-artifact@v2
+        uses: actions/download-artifact@v3
         with:
           name: linux-amd64-double-zipped
       - name: Extract release tarball
@@ -133,17 +133,6 @@ jobs:
           mkdir -p ~/lib
           tar -C ~/lib -xf tinygo.linux-amd64.tar.gz
           ln -s ~/lib/tinygo/bin/tinygo ~/go/bin/tinygo
-      - name: Install apt dependencies
-        run: |
-          sudo apt-get install --no-install-recommends \
-              gcc-avr \
-              avr-libc
-      - name: "Install Xtensa toolchain"
-        run: |
-          curl -L https://github.com/espressif/crosstool-NG/releases/download/esp-2020r2/xtensa-esp32-elf-gcc8_2_0-esp-2020r2-linux-amd64.tar.gz -o xtensa-esp32-elf-gcc8_2_0-esp-2020r2-linux-amd64.tar.gz
-          sudo tar -C /usr/local -xf xtensa-esp32-elf-gcc8_2_0-esp-2020r2-linux-amd64.tar.gz
-          sudo ln -s /usr/local/xtensa-esp32-elf/bin/xtensa-esp32-elf-ld /usr/local/bin/xtensa-esp32-elf-ld
-          rm xtensa-esp32-elf-gcc8_2_0-esp-2020r2-linux-amd64.tar.gz
       - run: make tinygo-test-wasi-fast
       - run: make smoketest
   assert-test-linux:
@@ -152,7 +141,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
         with:
           submodules: true
       - name: Install apt dependencies
@@ -164,8 +153,6 @@ jobs:
               qemu-system-arm \
               qemu-system-riscv32 \
               qemu-user \
-              gcc-avr \
-              avr-libc \
               simavr \
               ninja-build
       - name: Install Go
@@ -174,7 +161,7 @@ jobs:
           go-version: '1.19'
           cache: true
       - name: Install Node.js
-        uses: actions/setup-node@v2
+        uses: actions/setup-node@v3
         with:
           node-version: '14'
       - name: Install wasmtime
@@ -185,7 +172,7 @@ jobs:
         uses: actions/cache@v3
         id: cache-llvm-source
         with:
-          key: llvm-source-14-linux-asserts-v2
+          key: llvm-source-15-linux-asserts-v2
           path: |
             llvm-project/clang/lib/Headers
             llvm-project/clang/include
@@ -199,7 +186,7 @@ jobs:
         uses: actions/cache@v3
         id: cache-llvm-build
         with:
-          key: llvm-build-14-linux-asserts-v1
+          key: llvm-build-15-linux-asserts-v2
           path: llvm-build
       - name: Build LLVM
         if: steps.cache-llvm-build.outputs.cache-hit != 'true'
@@ -238,12 +225,6 @@ jobs:
           echo "$(pwd)/build" >> $GITHUB_PATH
       - name: Test stdlib packages
         run: make tinygo-test
-      - name: Install Xtensa toolchain
-        run: |
-          curl -L https://github.com/espressif/crosstool-NG/releases/download/esp-2020r2/xtensa-esp32-elf-gcc8_2_0-esp-2020r2-linux-amd64.tar.gz -o xtensa-esp32-elf-gcc8_2_0-esp-2020r2-linux-amd64.tar.gz
-          sudo tar -C /usr/local -xf xtensa-esp32-elf-gcc8_2_0-esp-2020r2-linux-amd64.tar.gz
-          sudo ln -s /usr/local/xtensa-esp32-elf/bin/xtensa-esp32-elf-ld /usr/local/bin/xtensa-esp32-elf-ld
-          rm xtensa-esp32-elf-gcc8_2_0-esp-2020r2-linux-amd64.tar.gz
       - run: make smoketest
       - run: make wasmtest
       - run: make tinygo-baremetal
@@ -260,7 +241,7 @@ jobs:
     needs: build-linux
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
       - name: Install apt dependencies
         run: |
           sudo apt-get update
@@ -277,7 +258,7 @@ jobs:
         uses: actions/cache@v3
         id: cache-llvm-source
         with:
-          key: llvm-source-14-linux-v2
+          key: llvm-source-15-linux-v2
           path: |
             llvm-project/clang/lib/Headers
             llvm-project/clang/include
@@ -291,7 +272,7 @@ jobs:
         uses: actions/cache@v3
         id: cache-llvm-build
         with:
-          key: llvm-build-14-linux-arm-v1
+          key: llvm-build-15-linux-arm-v2
           path: llvm-build
       - name: Build LLVM
         if: steps.cache-llvm-build.outputs.cache-hit != 'true'
@@ -326,7 +307,7 @@ jobs:
         run: |
           make CROSS=arm-linux-gnueabihf
       - name: Download amd64 release
-        uses: actions/download-artifact@v2
+        uses: actions/download-artifact@v3
         with:
           name: linux-amd64-double-zipped
       - name: Extract amd64 release
@@ -343,7 +324,7 @@ jobs:
           cp -p build/release.tar.gz /tmp/tinygo.linux-arm.tar.gz
           cp -p build/release.deb    /tmp/tinygo_armhf.deb
       - name: Publish release artifact
-        uses: actions/upload-artifact@v2
+        uses: actions/upload-artifact@v3
         with:
           name: linux-arm-double-zipped
           path: |
@@ -359,7 +340,7 @@ jobs:
     needs: build-linux
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
       - name: Install apt dependencies
         run: |
           sudo apt-get update
@@ -377,7 +358,7 @@ jobs:
         uses: actions/cache@v3
         id: cache-llvm-source
         with:
-          key: llvm-source-14-linux-v1
+          key: llvm-source-15-linux-v2
           path: |
             llvm-project/clang/lib/Headers
             llvm-project/clang/include
@@ -391,7 +372,7 @@ jobs:
         uses: actions/cache@v3
         id: cache-llvm-build
         with:
-          key: llvm-build-14-linux-arm64-v1
+          key: llvm-build-15-linux-arm64-v2
           path: llvm-build
       - name: Build LLVM
         if: steps.cache-llvm-build.outputs.cache-hit != 'true'
@@ -423,7 +404,7 @@ jobs:
         run: |
           make CROSS=aarch64-linux-gnu
       - name: Download amd64 release
-        uses: actions/download-artifact@v2
+        uses: actions/download-artifact@v3
         with:
           name: linux-amd64-double-zipped
       - name: Extract amd64 release
@@ -440,7 +421,7 @@ jobs:
           cp -p build/release.tar.gz /tmp/tinygo.linux-arm64.tar.gz
           cp -p build/release.deb    /tmp/tinygo_arm64.deb
       - name: Publish release artifact
-        uses: actions/upload-artifact@v2
+        uses: actions/upload-artifact@v3
         with:
           name: linux-arm64-double-zipped
           path: |

.github/workflows/windows.yml

@@ -23,7 +23,7 @@ jobs:
         run: |
           scoop install ninja binaryen
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
         with:
           submodules: true
       - name: Install Go
@@ -35,7 +35,7 @@ jobs:
         uses: actions/cache@v3
         id: cache-llvm-source
         with:
-          key: llvm-source-14-windows-v2
+          key: llvm-source-15-windows-v2
           path: |
             llvm-project/clang/lib/Headers
             llvm-project/clang/include
@@ -49,7 +49,7 @@ jobs:
         uses: actions/cache@v3
         id: cache-llvm-build
         with:
-          key: llvm-build-14-windows-v2
+          key: llvm-build-15-windows-v2
           path: llvm-build
       - name: Build LLVM
         if: steps.cache-llvm-build.outputs.cache-hit != 'true'
@@ -91,14 +91,91 @@ jobs:
         # - 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@v2
+        uses: actions/upload-artifact@v3
         with:
           name: release-double-zipped
           path: build/release/release.zip
+
+  smoke-test-windows:
+    runs-on: windows-2022
+    needs: build-windows
+    steps:
+      - uses: brechtm/setup-scoop@v2
+        with:
+          scoop_update: 'false'
+      - name: Install Dependencies
+        shell: bash
+        run: |
+          scoop install binaryen
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Install Go
+        uses: actions/setup-go@v3
+        with:
+          go-version: '1.19'
+          cache: true
+      - name: Download TinyGo build
+        uses: actions/download-artifact@v2
+        with:
+          name: release-double-zipped
+          path: build/
+      - name: Unzip TinyGo build
+        shell: bash
+        working-directory: build
+        run: 7z x release.zip -r
       - name: Smoke tests
         shell: bash
-        run: make smoketest TINYGO=$(PWD)/build/tinygo AVR=0 XTENSA=0
+        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@v2
+      - name: Install Go
+        uses: actions/setup-go@v3
+        with:
+          go-version: '1.19'
+          cache: true
+      - name: Download TinyGo build
+        uses: actions/download-artifact@v2
+        with:
+          name: release-double-zipped
+          path: build/
+      - name: Unzip TinyGo build
+        shell: bash
+        working-directory: build
+        run: 7z x release.zip -r
       - name: Test stdlib packages
-        run: make tinygo-test
+        run: make tinygo-test TINYGO=$(PWD)/build/tinygo/bin/tinygo
+
+  stdlib-wasi-test-windows:
+    runs-on: windows-2022
+    needs: build-windows
+    steps:
+      - uses: brechtm/setup-scoop@v2
+        with:
+          scoop_update: 'false'
+      - name: Install Dependencies
+        shell: bash
+        run: |
+          scoop install binaryen wasmtime
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Install Go
+        uses: actions/setup-go@v3
+        with:
+          go-version: '1.19'
+          cache: true
+      - name: Download TinyGo build
+        uses: actions/download-artifact@v2
+        with:
+          name: release-double-zipped
+          path: build/
+      - name: Unzip TinyGo build
+        shell: bash
+        working-directory: build
+        run: 7z x release.zip -r
       - name: Test stdlib packages on wasi
-        run: make tinygo-test-wasi-fast
+        run: make tinygo-test-wasi-fast TINYGO=$(PWD)/build/tinygo/bin/tinygo

CHANGELOG.md

@@ -1,3 +1,87 @@
+0.26.0
+---
+
+* **general**
+  - remove support for LLVM 13
+  - remove calls to deprecated ioutil package
+  - move from `os.IsFoo` to `errors.Is(err, ErrFoo)`
+  - fix for builds using an Android host
+  - make interp timeout configurable from command line
+  - ignore ports with VID/PID if there is no candidates
+  - drop support for Go 1.16 and Go 1.17
+  - update serial package to v1.3.5 for latest bugfixes
+  - remove GOARM from `tinygo info`
+  - add flag for setting the goroutine stack size
+  - add serial port monitoring functionality
+* **compiler**
+  - `cgo`: implement support for static functions
+  - `cgo`: fix panic when FuncType.Results is nil
+  - `compiler`: add aliases for `edwards25519/field.feMul` and `field.feSquare`
+  - `compiler`: fix incorrect DWARF type in some generic parameters
+  - `compiler`: use LLVM math builtins everywhere
+  - `compiler`: replace some math operation bodies with LLVM intrinsics
+  - `compiler`: replace math aliases with intrinsics
+  - `compiler`: fix `unsafe.Sizeof` for chan and map values
+  - `compileopts`: use tags parser from buildutil
+  - `compileopts`: use backticks for regexp to avoid extra escapes
+  - `compileopts`: fail fast on duplicate values in target field slices
+  - `compileopts`: fix windows/arm target triple
+  - `compileopts`: improve error handling when loading target/*.json
+  - `compileopts`: add support for stlink-dap programmer
+  - `compileopts`: do not complain about `-no-debug` on MacOS
+  - `goenv`: support `GOOS=android`
+  - `interp`: fix reading from external global
+  - `loader`: fix link error for `crypto/internal/boring/sig.StandardCrypto`
+* **standard library**
+  - rename assembly files to .S extension
+  - `machine`: add PWM peripheral comments to pins
+  - `machine`: improve UARTParity slightly
+  - `machine`: do not export DFU_MAGIC_* constants on nrf52840
+  - `machine`: rename `PinInputPullUp`/`PinInputPullDown`
+  - `machine`: add `KHz`, `MHz`, `GHz` constants, deprecate `TWI_FREQ_*` constants
+  - `machine`: remove level triggered pin interrupts
+  - `machine`: do not expose `RESET_MAGIC_VALUE`
+  - `machine`: use `NoPin` constant where appropriate (instead of `0` for example)
+  - `net`: sync net.go with Go 1.18 stdlib
+  - `os`: add `SyscallError.Timeout`
+  - `os`: add `ErrProcessDone` error
+  - `reflect`: implement `CanInterface` and fix string `Index`
+  - `runtime`: make `MemStats` available to leaking collector
+  - `runtime`: add `MemStats.TotalAlloc`
+  - `runtime`: add `MemStats.Mallocs` and `Frees`
+  - `runtime`: add support for `time.NewTimer` and `time.NewTicker`
+  - `runtime`: implement `resetTimer`
+  - `runtime`: ensure some headroom for the GC to run
+  - `runtime`: make gc and scheduler asserts settable with build tags
+  - `runtime/pprof`: add `WriteHeapProfile`
+  - `runtime/pprof`: `runtime/trace`: stub some additional functions
+  - `sync`: implement `Map.LoadAndDelete`
+  - `syscall`: group WASI consts by purpose
+  - `syscall`: add WASI `{D,R}SYNC`, `NONBLOCK` FD flags
+  - `syscall`: add ENOTCONN on darwin
+  - `testing`: add support for -benchmem
+* **targets**
+  - remove USB vid/pid pair of bootloader
+  - `esp32c3`: remove unused `UARTStopBits` constants
+  - `nrf`: implement `GetRNG` function
+  - `nrf`: `rp2040`: add `machine.ReadTemperature`
+  - `nrf52`: cleanup s140v6 and s140v7 uf2 targets
+  - `rp2040`: implement semi-random RNG based on ROSC based on pico-sdk
+  - `wasm`: add summary of wasm examples and fix callback bug
+  - `wasm`: do not allow undefined symbols (`--allow-undefined`)
+  - `wasm`: make sure buffers returned by `malloc` are kept until `free` is called
+  - `windows`: save and restore xmm registers when switching goroutines
+* **boards**
+  - add Pimoroni's Tufty2040
+  - add XIAO ESP32C3
+  - add Adafruit QT2040
+  - add Adafruit QT Py RP2040
+  - `esp32c3-12f`: `matrixportal-m4`: `p1am-100`: remove duplicate build tags
+  - `hifive1-qemu`: remove this emulated board
+  - `wioterminal`: add UART3 for RTL8720DN
+  - `xiao-ble`: fix usbpid
+
+
 0.25.0
 ---
 

Dockerfile

@@ -2,7 +2,7 @@
 FROM golang:1.19 AS tinygo-llvm
 
 RUN apt-get update && \
-    apt-get install -y apt-utils make cmake clang-11 binutils-avr gcc-avr avr-libc ninja-build
+    apt-get install -y apt-utils make cmake clang-11 ninja-build
 
 COPY ./Makefile /tinygo/Makefile
 
@@ -15,18 +15,8 @@ FROM tinygo-llvm AS tinygo-llvm-build
 RUN cd /tinygo/ && \
     make llvm-build
 
-# tinygo-xtensa stage installs tools needed for ESP32
-FROM tinygo-llvm-build AS tinygo-xtensa
-
-ARG xtensa_version="1.22.0-80-g6c4433a-5.2.0"
-RUN cd /tmp/ && \
-    wget -q https://dl.espressif.com/dl/xtensa-esp32-elf-linux64-${xtensa_version}.tar.gz && \
-    tar xzf xtensa-esp32-elf-linux64-${xtensa_version}.tar.gz && \
-    cp ./xtensa-esp32-elf/bin/xtensa-esp32-elf-ld /usr/local/bin/ && \
-    rm -rf /tmp/xtensa*
-
 # tinygo-compiler stage builds the compiler itself
-FROM tinygo-xtensa AS tinygo-compiler
+FROM tinygo-llvm-build AS tinygo-compiler
 
 COPY . /tinygo
 

Makefile

@@ -10,7 +10,7 @@ LLD_SRC ?= $(LLVM_PROJECTDIR)/lld
 
 # Try to autodetect LLVM build tools.
 # Versions are listed here in descending priority order.
-LLVM_VERSIONS = 14 13 12 11
+LLVM_VERSIONS = 15 14 13 12 11
 errifempty = $(if $(1),$(1),$(error $(2)))
 detect = $(shell which $(call errifempty,$(firstword $(foreach p,$(2),$(shell command -v $(p) 2> /dev/null && echo $(p)))),failed to locate $(1) at any of: $(2)))
 toolSearchPathsVersion = $(1)-$(2)
@@ -56,6 +56,12 @@ else
     LLVM_OPTION += '-DLLVM_ENABLE_ASSERTIONS=OFF'
 endif
 
+# Enable AddressSanitizer
+ifeq (1, $(ASAN))
+    LLVM_OPTION += -DLLVM_USE_SANITIZER=Address
+    CGO_LDFLAGS += -fsanitize=address
+endif
+
 ifeq (1, $(STATIC))
     # Build TinyGo as a fully statically linked binary (no dynamically loaded
     # libraries such as a libc). This is not supported with glibc which is used
@@ -107,7 +113,7 @@ endif
 
 .PHONY: all tinygo test $(LLVM_BUILDDIR) llvm-source clean fmt gen-device gen-device-nrf gen-device-nxp gen-device-avr gen-device-rp
 
-LLVM_COMPONENTS = all-targets analysis asmparser asmprinter bitreader bitwriter codegen core coroutines coverage debuginfodwarf debuginfopdb executionengine frontendopenmp instrumentation interpreter ipo irreader libdriver linker lto mc mcjit objcarcopts option profiledata scalaropts support target windowsmanifest
+LLVM_COMPONENTS = all-targets analysis asmparser asmprinter bitreader bitwriter codegen core coroutines coverage debuginfodwarf debuginfopdb executionengine frontendopenmp instrumentation interpreter ipo irreader libdriver linker lto mc mcjit objcarcopts option profiledata scalaropts support target windowsdriver windowsmanifest
 
 ifeq ($(OS),Windows_NT)
     EXE = .exe
@@ -142,7 +148,7 @@ else
 endif
 
 # Libraries that should be linked in for the statically linked Clang.
-CLANG_LIB_NAMES = clangAnalysis clangAST clangASTMatchers clangBasic clangCodeGen clangCrossTU clangDriver clangDynamicASTMatchers clangEdit clangFormat clangFrontend clangFrontendTool clangHandleCXX clangHandleLLVM clangIndex clangLex clangParse clangRewrite clangRewriteFrontend clangSema clangSerialization clangTooling clangToolingASTDiff clangToolingCore clangToolingInclusions
+CLANG_LIB_NAMES = clangAnalysis clangAST clangASTMatchers clangBasic clangCodeGen clangCrossTU clangDriver clangDynamicASTMatchers clangEdit clangExtractAPI clangFormat clangFrontend clangFrontendTool clangHandleCXX clangHandleLLVM clangIndex clangLex clangParse clangRewrite clangRewriteFrontend clangSema clangSerialization clangSupport clangTooling clangToolingASTDiff clangToolingCore clangToolingInclusions
 CLANG_LIBS = $(START_GROUP) $(addprefix -l,$(CLANG_LIB_NAMES)) $(END_GROUP) -lstdc++
 
 # Libraries that should be linked in for the statically linked LLD.
@@ -230,7 +236,7 @@ gen-device-rp: build/gen-device-svd
 
 # Get LLVM sources.
 $(LLVM_PROJECTDIR)/llvm:
-	git clone -b xtensa_release_14.0.0-patched --depth=1 https://github.com/tinygo-org/llvm-project $(LLVM_PROJECTDIR)
+	git clone -b xtensa_release_15.x --depth=1 https://github.com/espressif/llvm-project $(LLVM_PROJECTDIR)
 llvm-source: $(LLVM_PROJECTDIR)/llvm
 
 # Configure LLVM.
@@ -257,7 +263,7 @@ endif
 wasi-libc: lib/wasi-libc/sysroot/lib/wasm32-wasi/libc.a
 lib/wasi-libc/sysroot/lib/wasm32-wasi/libc.a:
 	@if [ ! -e lib/wasi-libc/Makefile ]; then echo "Submodules have not been downloaded. Please download them using:\n  git submodule update --init"; exit 1; fi
-	cd lib/wasi-libc && make -j4 WASM_CFLAGS="-O2 -g -DNDEBUG -mnontrapping-fptoint -msign-ext" MALLOC_IMPL=none CC=$(CLANG) AR=$(LLVM_AR) NM=$(LLVM_NM)
+	cd lib/wasi-libc && make -j4 EXTRA_CFLAGS="-O2 -g -DNDEBUG -mnontrapping-fptoint -msign-ext" MALLOC_IMPL=none CC=$(CLANG) AR=$(LLVM_AR) NM=$(LLVM_NM)
 
 
 # Build the Go compiler.
@@ -280,7 +286,6 @@ TEST_PACKAGES_FAST = \
 	container/list \
 	container/ring \
 	crypto/des \
-	crypto/internal/subtle \
 	crypto/md5 \
 	crypto/rc4 \
 	crypto/sha1 \
@@ -606,6 +611,8 @@ endif
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=qtpy-rp2040         examples/echo
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=kb2040              examples/echo
+	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=macropad-rp2040 	examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=badger2040          examples/blinky1
@@ -616,6 +623,8 @@ endif
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=xiao-rp2040         examples/blinky1
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=waveshare-rp2040-zero examples/echo
+	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=challenger-rp2040    examples/blinky1
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=trinkey-qt2040      examples/temp
@@ -668,11 +677,12 @@ ifneq ($(STM32), 0)
 	$(TINYGO) build -size short -o test.hex -target=swan                examples/blinky1
 	@$(MD5SUM) test.hex
 endif
-ifneq ($(AVR), 0)
 	$(TINYGO) build -size short -o test.hex -target=atmega1284p         examples/serial
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=arduino             examples/blinky1
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=arduino-leonardo    examples/blinky1
+	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=arduino             examples/pwm
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=arduino -scheduler=tasks  examples/blinky1
@@ -687,7 +697,6 @@ ifneq ($(AVR), 0)
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=digispark -gc=leaking examples/blinky1
 	@$(MD5SUM) test.hex
-endif
 ifneq ($(XTENSA), 0)
 	$(TINYGO) build -size short -o test.bin -target=esp32-mini32      	examples/blinky1
 	@$(MD5SUM) test.bin
@@ -729,6 +738,7 @@ endif
 	@$(MD5SUM) test.hex
 	GOOS=linux GOARCH=arm $(TINYGO) build -size short -o test.elf       ./testdata/cgo
 	GOOS=windows GOARCH=amd64 $(TINYGO) build -size short -o test.exe   ./testdata/cgo
+	GOOS=windows GOARCH=arm64 $(TINYGO) build -size short -o test.exe   ./testdata/cgo
 	GOOS=darwin GOARCH=amd64 $(TINYGO) build  -size short -o test       ./testdata/cgo
 	GOOS=darwin GOARCH=arm64 $(TINYGO) build  -size short -o test       ./testdata/cgo
 ifneq ($(OS),Windows_NT)
@@ -780,6 +790,7 @@ endif
 	@cp -rp lib/musl/src/exit            build/release/tinygo/lib/musl/src
 	@cp -rp lib/musl/src/include         build/release/tinygo/lib/musl/src
 	@cp -rp lib/musl/src/internal        build/release/tinygo/lib/musl/src
+	@cp -rp lib/musl/src/legacy          build/release/tinygo/lib/musl/src
 	@cp -rp lib/musl/src/malloc          build/release/tinygo/lib/musl/src
 	@cp -rp lib/musl/src/mman            build/release/tinygo/lib/musl/src
 	@cp -rp lib/musl/src/math            build/release/tinygo/lib/musl/src

README.md

@@ -43,12 +43,13 @@ See the [getting started instructions](https://tinygo.org/getting-started/) for
 
 You can compile TinyGo programs for microcontrollers, WebAssembly and Linux.
 
-The following 91 microcontroller boards are currently supported:
+The following 94 microcontroller boards are currently supported:
 
 * [Adafruit Circuit Playground Bluefruit](https://www.adafruit.com/product/4333)
 * [Adafruit Circuit Playground Express](https://www.adafruit.com/product/3333)
 * [Adafruit CLUE](https://www.adafruit.com/product/4500)
 * [Adafruit Feather M0](https://www.adafruit.com/product/2772)
+* [Adafruit Feather M0 Express](https://www.adafruit.com/product/3403)
 * [Adafruit Feather M4](https://www.adafruit.com/product/3857)
 * [Adafruit Feather M4 CAN](https://www.adafruit.com/product/4759)
 * [Adafruit Feather nRF52840 Express](https://www.adafruit.com/product/4062)
@@ -59,6 +60,7 @@ The following 91 microcontroller boards are currently supported:
 * [Adafruit ItsyBitsy M0](https://www.adafruit.com/product/3727)
 * [Adafruit ItsyBitsy M4](https://www.adafruit.com/product/3800)
 * [Adafruit ItsyBitsy nRF52840](https://www.adafruit.com/product/4481)
+* [Adafruit KB2040](https://www.adafruit.com/product/5302)
 * [Adafruit MacroPad RP2040](https://www.adafruit.com/product/5100)
 * [Adafruit Matrix Portal M4](https://www.adafruit.com/product/4745)
 * [Adafruit Metro M4 Express Airlift](https://www.adafruit.com/product/4000)
@@ -136,8 +138,10 @@ The following 91 microcontroller boards are currently supported:
 * [ST Micro STM32F103XX "Bluepill"](https://stm32-base.org/boards/STM32F103C8T6-Blue-Pill)
 * [ST Micro STM32F407 "Discovery"](https://www.st.com/en/evaluation-tools/stm32f4discovery.html)
 * [ST Micro STM32F469 "Discovery"](https://www.st.com/content/st_com/en/products/evaluation-tools/product-evaluation-tools/mcu-mpu-eval-tools/stm32-mcu-mpu-eval-tools/stm32-discovery-kits/32f469idiscovery.html)
-* [X9 Pro smartwatch](https://github.com/curtpw/nRF5x-device-reverse-engineering/tree/master/X9-nrf52832-activity-tracker/)
 * [The Things Industries Generic Node Sensor Edition](https://www.genericnode.com/docs/sensor-edition/)
+* [Waveshare RP2040-Zero](https://www.waveshare.com/wiki/RP2040-Zero)
+* [X9 Pro smartwatch](https://github.com/curtpw/nRF5x-device-reverse-engineering/tree/master/X9-nrf52832-activity-tracker/)
+
 
 For more information, see [this list of boards](https://tinygo.org/microcontrollers/). Pull requests for additional support are welcome!
 

builder/build.go

@@ -42,8 +42,8 @@ type BuildResult struct {
 	// information. Used for GDB for example.
 	Executable string
 
-	// A path to the output binary. It will be removed after Build returns, so
+	// A path to the output binary. It is stored in the tmpdir directory of the
-	// if it should be kept it must be copied or moved away.
+	// Build function, so if it should be kept it must be copied or moved away.
 	// It is often the same as Executable, but differs if the output format is
 	// .hex for example (instead of the usual ELF).
 	Binary string
@@ -94,23 +94,16 @@ type packageAction struct {
 //
 // The error value may be of type *MultiError. Callers will likely want to check
 // for this case and print such errors individually.
-func Build(pkgName, outpath string, config *compileopts.Config, action func(BuildResult) error) error {
+func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildResult, error) {
 	// Read the build ID of the tinygo binary.
 	// Used as a cache key for package builds.
 	compilerBuildID, err := ReadBuildID()
 	if err != nil {
-		return err
+		return BuildResult{}, err
 	}
 
-	// Create a temporary directory for intermediary files.
-	dir, err := os.MkdirTemp("", "tinygo")
-	if err != nil {
-		return err
-	}
 	if config.Options.Work {
-		fmt.Printf("WORK=%s\n", dir)
+		fmt.Printf("WORK=%s\n", tmpdir)
-	} else {
-		defer os.RemoveAll(dir)
 	}
 
 	// Look up the build cache directory, which is used to speed up incremental
@@ -119,7 +112,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 	if cacheDir == "off" {
 		// Use temporary build directory instead, effectively disabling the
 		// build cache.
-		cacheDir = dir
+		cacheDir = tmpdir
 	}
 
 	// Check for a libc dependency.
@@ -129,40 +122,40 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 	var libcDependencies []*compileJob
 	switch config.Target.Libc {
 	case "darwin-libSystem":
-		job := makeDarwinLibSystemJob(config, dir)
+		job := makeDarwinLibSystemJob(config, tmpdir)
 		libcDependencies = append(libcDependencies, job)
 	case "musl":
-		job, unlock, err := Musl.load(config, dir)
+		job, unlock, err := Musl.load(config, tmpdir)
 		if err != nil {
-			return err
+			return BuildResult{}, err
 		}
 		defer unlock()
 		libcDependencies = append(libcDependencies, dummyCompileJob(filepath.Join(filepath.Dir(job.result), "crt1.o")))
 		libcDependencies = append(libcDependencies, job)
 	case "picolibc":
-		libcJob, unlock, err := Picolibc.load(config, dir)
+		libcJob, unlock, err := Picolibc.load(config, tmpdir)
 		if err != nil {
-			return err
+			return BuildResult{}, err
 		}
 		defer unlock()
 		libcDependencies = append(libcDependencies, libcJob)
 	case "wasi-libc":
 		path := filepath.Join(root, "lib/wasi-libc/sysroot/lib/wasm32-wasi/libc.a")
 		if _, err := os.Stat(path); errors.Is(err, fs.ErrNotExist) {
-			return errors.New("could not find wasi-libc, perhaps you need to run `make wasi-libc`?")
+			return BuildResult{}, errors.New("could not find wasi-libc, perhaps you need to run `make wasi-libc`?")
 		}
 		libcDependencies = append(libcDependencies, dummyCompileJob(path))
 	case "mingw-w64":
-		_, unlock, err := MinGW.load(config, dir)
+		_, unlock, err := MinGW.load(config, tmpdir)
 		if err != nil {
-			return err
+			return BuildResult{}, err
 		}
 		unlock()
-		libcDependencies = append(libcDependencies, makeMinGWExtraLibs(dir)...)
+		libcDependencies = append(libcDependencies, makeMinGWExtraLibs(tmpdir, config.GOARCH())...)
 	case "":
 		// no library specified, so nothing to do
 	default:
-		return fmt.Errorf("unknown libc: %s", config.Target.Libc)
+		return BuildResult{}, fmt.Errorf("unknown libc: %s", config.Target.Libc)
 	}
 
 	optLevel, sizeLevel, _ := config.OptLevels()
@@ -170,6 +163,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		Triple:          config.Triple(),
 		CPU:             config.CPU(),
 		Features:        config.Features(),
+		ABI:             config.ABI(),
 		GOOS:            config.GOOS(),
 		GOARCH:          config.GOARCH(),
 		CodeModel:       config.CodeModel(),
@@ -188,7 +182,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 	// address spaces, etc).
 	machine, err := compiler.NewTargetMachine(compilerConfig)
 	if err != nil {
-		return err
+		return BuildResult{}, err
 	}
 	defer machine.Dispose()
 
@@ -196,12 +190,21 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 	lprogram, err := loader.Load(config, pkgName, config.ClangHeaders, types.Config{
 		Sizes: compiler.Sizes(machine),
 	})
-	if err != nil {
+	result := BuildResult{
-		return err
+		ModuleRoot: lprogram.MainPkg().Module.Dir,
+		MainDir:    lprogram.MainPkg().Dir,
+		ImportPath: lprogram.MainPkg().ImportPath,
+	}
+	if result.ModuleRoot == "" {
+		// If there is no module root, just the regular root.
+		result.ModuleRoot = lprogram.MainPkg().Root
+	}
+	if err != nil { // failed to load AST
+		return result, err
 	}
 	err = lprogram.Parse()
 	if err != nil {
-		return err
+		return result, err
 	}
 
 	// Create the *ssa.Program. This does not yet build the entire SSA of the
@@ -270,7 +273,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 						}
 					}
 
-					job.result, err = createEmbedObjectFile(string(data), hexSum, name, pkg.OriginalDir(), dir, compilerConfig)
+					job.result, err = createEmbedObjectFile(string(data), hexSum, name, pkg.OriginalDir(), tmpdir, compilerConfig)
 					return err
 				},
 			}
@@ -284,7 +287,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		for _, imported := range pkg.Pkg.Imports() {
 			job, ok := packageActionIDJobs[imported.Path()]
 			if !ok {
-				return fmt.Errorf("package %s imports %s but couldn't find dependency", pkg.ImportPath, imported.Path())
+				return result, fmt.Errorf("package %s imports %s but couldn't find dependency", pkg.ImportPath, imported.Path())
 			}
 			importedPackages = append(importedPackages, job)
 			actionIDDependencies = append(actionIDDependencies, job)
@@ -370,7 +373,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 				// Packages are compiled independently anyway.
 				for _, cgoHeader := range pkg.CGoHeaders {
 					// Store the header text in a temporary file.
-					f, err := os.CreateTemp(dir, "cgosnippet-*.c")
+					f, err := os.CreateTemp(tmpdir, "cgosnippet-*.c")
 					if err != nil {
 						return err
 					}
@@ -418,7 +421,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 						return errors.New("global not found: " + globalName)
 					}
 					name := global.Name()
-					newGlobal := llvm.AddGlobal(mod, global.Type().ElementType(), name+".tmp")
+					newGlobal := llvm.AddGlobal(mod, global.GlobalValueType(), name+".tmp")
 					global.ReplaceAllUsesWith(newGlobal)
 					global.EraseFromParentAsGlobal()
 					newGlobal.SetName(name)
@@ -523,7 +526,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 				if pkgInit.IsNil() {
 					panic("init not found for " + pkg.Pkg.Path())
 				}
-				irbuilder.CreateCall(pkgInit, []llvm.Value{llvm.Undef(i8ptrType)}, "")
+				irbuilder.CreateCall(pkgInit.GlobalValueType(), pkgInit, []llvm.Value{llvm.Undef(i8ptrType)}, "")
 			}
 			irbuilder.CreateRetVoid()
 
@@ -579,17 +582,17 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		// Run jobs to produce the LLVM module.
 		err := runJobs(programJob, config.Options.Semaphore)
 		if err != nil {
-			return err
+			return result, err
 		}
 		// Generate output.
 		switch outext {
 		case ".o":
 			llvmBuf, err := machine.EmitToMemoryBuffer(mod, llvm.ObjectFile)
 			if err != nil {
-				return err
+				return result, err
 			}
 			defer llvmBuf.Dispose()
-			return os.WriteFile(outpath, llvmBuf.Bytes(), 0666)
+			return result, os.WriteFile(outpath, llvmBuf.Bytes(), 0666)
 		case ".bc":
 			var buf llvm.MemoryBuffer
 			if config.UseThinLTO() {
@@ -598,10 +601,10 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 				buf = llvm.WriteBitcodeToMemoryBuffer(mod)
 			}
 			defer buf.Dispose()
-			return os.WriteFile(outpath, buf.Bytes(), 0666)
+			return result, os.WriteFile(outpath, buf.Bytes(), 0666)
 		case ".ll":
 			data := []byte(mod.String())
-			return os.WriteFile(outpath, data, 0666)
+			return result, os.WriteFile(outpath, data, 0666)
 		default:
 			panic("unreachable")
 		}
@@ -612,7 +615,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 	// run all jobs in parallel as far as possible.
 
 	// Add job to write the output object file.
-	objfile := filepath.Join(dir, "main.o")
+	objfile := filepath.Join(tmpdir, "main.o")
 	outputObjectFileJob := &compileJob{
 		description:  "generate output file",
 		dependencies: []*compileJob{programJob},
@@ -635,19 +638,19 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 
 	// Prepare link command.
 	linkerDependencies := []*compileJob{outputObjectFileJob}
-	executable := filepath.Join(dir, "main")
+	result.Executable = filepath.Join(tmpdir, "main")
 	if config.GOOS() == "windows" {
-		executable += ".exe"
+		result.Executable += ".exe"
 	}
-	tmppath := executable // final file
+	result.Binary = result.Executable // final file
-	ldflags := append(config.LDFlags(), "-o", executable)
+	ldflags := append(config.LDFlags(), "-o", result.Executable)
 
 	// Add compiler-rt dependency if needed. Usually this is a simple load from
 	// a cache.
 	if config.Target.RTLib == "compiler-rt" {
-		job, unlock, err := CompilerRT.load(config, dir)
+		job, unlock, err := CompilerRT.load(config, tmpdir)
 		if err != nil {
-			return err
+			return result, err
 		}
 		defer unlock()
 		linkerDependencies = append(linkerDependencies, job)
@@ -661,7 +664,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 		job := &compileJob{
 			description: "compile extra file " + path,
 			run: func(job *compileJob) error {
-				result, err := compileAndCacheCFile(abspath, dir, config.CFlags(), config.UseThinLTO(), config.Options.PrintCommands)
+				result, err := compileAndCacheCFile(abspath, tmpdir, config.CFlags(), config.UseThinLTO(), config.Options.PrintCommands)
 				job.result = result
 				return err
 			},
@@ -679,7 +682,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 			job := &compileJob{
 				description: "compile CGo file " + abspath,
 				run: func(job *compileJob) error {
-					result, err := compileAndCacheCFile(abspath, dir, pkg.CFlags, config.UseThinLTO(), config.Options.PrintCommands)
+					result, err := compileAndCacheCFile(abspath, tmpdir, pkg.CFlags, config.UseThinLTO(), config.Options.PrintCommands)
 					job.result = result
 					return err
 				},
@@ -700,21 +703,18 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 	// Add embedded files.
 	linkerDependencies = append(linkerDependencies, embedFileObjects...)
 
+	// Determine whether the compilation configuration would result in debug
+	// (DWARF) information in the object files.
+	var hasDebug = true
+	if config.GOOS() == "darwin" {
+		// Debug information isn't stored in the binary itself on MacOS but
+		// is left in the object files by default. The binary does store the
+		// path to these object files though.
+		hasDebug = false
+	}
+
 	// Strip debug information with -no-debug.
-	if !config.Debug() {
+	if hasDebug && !config.Debug() {
-		for _, tag := range config.BuildTags() {
-			if tag == "baremetal" {
-				// Don't use -no-debug on baremetal targets. It makes no sense:
-				// the debug information isn't flashed to the device anyway.
-				return fmt.Errorf("stripping debug information is unnecessary for baremetal targets")
-			}
-		}
-		if config.GOOS() == "darwin" {
-			// Debug information isn't stored in the binary itself on MacOS but
-			// is left in the object files by default. The binary does store the
-			// path to these object files though.
-			return errors.New("cannot remove debug information: MacOS doesn't store debug info in the executable by default")
-		}
 		if config.Target.Linker == "wasm-ld" {
 			// Don't just strip debug information, also compress relocations
 			// while we're at it. Relocations can only be compressed when debug
@@ -725,7 +725,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 			ldflags = append(ldflags, "--strip-debug")
 		} else {
 			// Other linkers may have different flags.
-			return errors.New("cannot remove debug information: unknown linker: " + config.Target.Linker)
+			return result, errors.New("cannot remove debug information: unknown linker: " + config.Target.Linker)
 		}
 	}
 
@@ -741,9 +741,6 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 				}
 				ldflags = append(ldflags, dependency.result)
 			}
-			if config.Options.PrintCommands != nil {
-				config.Options.PrintCommands(config.Target.Linker, ldflags...)
-			}
 			if config.UseThinLTO() {
 				ldflags = append(ldflags, "-mllvm", "-mcpu="+config.CPU())
 				if config.GOOS() == "windows" {
@@ -775,9 +772,12 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 						"-mllvm", "--rotation-max-header-size=0")
 				}
 			}
+			if config.Options.PrintCommands != nil {
+				config.Options.PrintCommands(config.Target.Linker, ldflags...)
+			}
 			err = link(config.Target.Linker, ldflags...)
 			if err != nil {
-				return &commandError{"failed to link", executable, err}
+				return &commandError{"failed to link", result.Executable, err}
 			}
 
 			var calculatedStacks []string
@@ -786,7 +786,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 				// Try to determine stack sizes at compile time.
 				// Don't do this by default as it usually doesn't work on
 				// unsupported architectures.
-				calculatedStacks, stackSizes, err = determineStackSizes(mod, executable)
+				calculatedStacks, stackSizes, err = determineStackSizes(mod, result.Executable)
 				if err != nil {
 					return err
 				}
@@ -796,41 +796,51 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 			if config.AutomaticStackSize() {
 				// Modify the .tinygo_stacksizes section that contains a stack size
 				// for each goroutine.
-				err = modifyStackSizes(executable, stackSizeLoads, stackSizes)
+				err = modifyStackSizes(result.Executable, stackSizeLoads, stackSizes)
 				if err != nil {
 					return fmt.Errorf("could not modify stack sizes: %w", err)
 				}
 			}
 			if config.RP2040BootPatch() {
 				// Patch the second stage bootloader CRC into the .boot2 section
-				err = patchRP2040BootCRC(executable)
+				err = patchRP2040BootCRC(result.Executable)
 				if err != nil {
 					return fmt.Errorf("could not patch RP2040 second stage boot loader: %w", err)
 				}
 			}
 
-			// Run wasm-opt if necessary.
+			// Run wasm-opt for wasm binaries
-			if config.Scheduler() == "asyncify" {
+			if arch := strings.Split(config.Triple(), "-")[0]; arch == "wasm32" {
-				var optLevel, shrinkLevel int
+				var opt string
 				switch config.Options.Opt {
 				case "none", "0":
+					opt = "-O0"
 				case "1":
-					optLevel = 1
+					opt = "-O1"
 				case "2":
-					optLevel = 2
+					opt = "-O2"
 				case "s":
-					optLevel = 2
+					opt = "-Os"
-					shrinkLevel = 1
 				case "z":
-					optLevel = 2
+					opt = "-Oz"
-					shrinkLevel = 2
 				default:
 					return fmt.Errorf("unknown opt level: %q", config.Options.Opt)
 				}
-				cmd := exec.Command(goenv.Get("WASMOPT"), "--asyncify", "-g",
+
-					"--optimize-level", strconv.Itoa(optLevel),
+				var args []string
-					"--shrink-level", strconv.Itoa(shrinkLevel),
+
-					executable, "--output", executable)
+				if config.Scheduler() == "asyncify" {
+					args = append(args, "--asyncify")
+				}
+
+				args = append(args,
+					opt,
+					"-g",
+					result.Executable,
+					"--output", result.Executable,
+				)
+
+				cmd := exec.Command(goenv.Get("WASMOPT"), args...)
 				cmd.Stdout = os.Stdout
 				cmd.Stderr = os.Stderr
 
@@ -846,7 +856,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 				for _, pkg := range lprogram.Sorted() {
 					packagePathMap[pkg.OriginalDir()] = pkg.Pkg.Path()
 				}
-				sizes, err := loadProgramSize(executable, packagePathMap)
+				sizes, err := loadProgramSize(result.Executable, packagePathMap)
 				if err != nil {
 					return err
 				}
@@ -882,7 +892,7 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 	// is simpler and cannot be parallelized.
 	err = runJobs(linkJob, config.Options.Semaphore)
 	if err != nil {
-		return err
+		return result, err
 	}
 
 	// Get an Intel .hex file or .bin file from the .elf file.
@@ -893,56 +903,43 @@ func Build(pkgName, outpath string, config *compileopts.Config, action func(Buil
 	case "hex", "bin":
 		// Extract raw binary, either encoding it as a hex file or as a raw
 		// firmware file.
-		tmppath = filepath.Join(dir, "main"+outext)
+		result.Binary = filepath.Join(tmpdir, "main"+outext)
-		err := objcopy(executable, tmppath, outputBinaryFormat)
+		err := objcopy(result.Executable, result.Binary, outputBinaryFormat)
 		if err != nil {
-			return err
+			return result, err
 		}
 	case "uf2":
 		// Get UF2 from the .elf file.
-		tmppath = filepath.Join(dir, "main"+outext)
+		result.Binary = filepath.Join(tmpdir, "main"+outext)
-		err := convertELFFileToUF2File(executable, tmppath, config.Target.UF2FamilyID)
+		err := convertELFFileToUF2File(result.Executable, result.Binary, config.Target.UF2FamilyID)
 		if err != nil {
-			return err
+			return result, err
 		}
 	case "esp32", "esp32-img", "esp32c3", "esp8266":
 		// Special format for the ESP family of chips (parsed by the ROM
 		// bootloader).
-		tmppath = filepath.Join(dir, "main"+outext)
+		result.Binary = filepath.Join(tmpdir, "main"+outext)
-		err := makeESPFirmareImage(executable, tmppath, outputBinaryFormat)
+		err := makeESPFirmareImage(result.Executable, result.Binary, outputBinaryFormat)
 		if err != nil {
-			return err
+			return result, err
 		}
 	case "nrf-dfu":
 		// special format for nrfutil for Nordic chips
-		tmphexpath := filepath.Join(dir, "main.hex")
+		tmphexpath := filepath.Join(tmpdir, "main.hex")
-		err := objcopy(executable, tmphexpath, "hex")
+		err := objcopy(result.Executable, tmphexpath, "hex")
 		if err != nil {
-			return err
+			return result, err
 		}
-		tmppath = filepath.Join(dir, "main"+outext)
+		result.Binary = filepath.Join(tmpdir, "main"+outext)
-		err = makeDFUFirmwareImage(config.Options, tmphexpath, tmppath)
+		err = makeDFUFirmwareImage(config.Options, tmphexpath, result.Binary)
 		if err != nil {
-			return err
+			return result, err
 		}
 	default:
-		return fmt.Errorf("unknown output binary format: %s", outputBinaryFormat)
+		return result, fmt.Errorf("unknown output binary format: %s", outputBinaryFormat)
 	}
 
-	// If there's a module root, use that.
+	return result, nil
-	moduleroot := lprogram.MainPkg().Module.Dir
-	if moduleroot == "" {
-		// if not, just the regular root
-		moduleroot = lprogram.MainPkg().Root
-	}
-
-	return action(BuildResult{
-		Executable: executable,
-		Binary:     tmppath,
-		MainDir:    lprogram.MainPkg().Dir,
-		ModuleRoot: moduleroot,
-		ImportPath: lprogram.MainPkg().ImportPath,
-	})
 }
 
 // createEmbedObjectFile creates a new object file with the given contents, for
@@ -1086,7 +1083,6 @@ func optimizeProgram(mod llvm.Module, config *compileopts.Config) error {
 	// cannot be represented exactly in JavaScript (JS only has doubles). To
 	// keep functions interoperable, pass int64 types as pointers to
 	// stack-allocated values.
-	// Use -wasm-abi=generic to disable this behaviour.
 	if config.WasmAbi() == "js" {
 		err := transform.ExternalInt64AsPtr(mod, config)
 		if err != nil {
@@ -1137,7 +1133,7 @@ func setGlobalValues(mod llvm.Module, globals map[string]map[string]string) erro
 
 			// A strin is a {ptr, len} pair. We need these types to build the
 			// initializer.
-			initializerType := global.Type().ElementType()
+			initializerType := global.GlobalValueType()
 			if initializerType.TypeKind() != llvm.StructTypeKind || initializerType.StructName() == "" {
 				return fmt.Errorf("%s: not a string", globalName)
 			}
@@ -1156,7 +1152,7 @@ func setGlobalValues(mod llvm.Module, globals map[string]map[string]string) erro
 
 			// Create the string value, which is a {ptr, len} pair.
 			zero := llvm.ConstInt(mod.Context().Int32Type(), 0, false)
-			ptr := llvm.ConstGEP(buf, []llvm.Value{zero, zero})
+			ptr := llvm.ConstGEP(bufInitializer.Type(), buf, []llvm.Value{zero, zero})
 			if ptr.Type() != elementTypes[0] {
 				return fmt.Errorf("%s: not a string", globalName)
 			}

builder/builder_test.go

@@ -59,6 +59,7 @@ func TestClangAttributes(t *testing.T) {
 		{GOOS: "darwin", GOARCH: "amd64"},
 		{GOOS: "darwin", GOARCH: "arm64"},
 		{GOOS: "windows", GOARCH: "amd64"},
+		{GOOS: "windows", GOARCH: "arm64"},
 	} {
 		name := "GOOS=" + options.GOOS + ",GOARCH=" + options.GOARCH
 		if options.GOARCH == "arm" {

builder/builtins.go

@@ -162,6 +162,15 @@ var aeabiBuiltins = []string{
 	"udivmodsi4.c",
 }
 
+var avrBuiltins = []string{
+	"avr/divmodhi4.S",
+	"avr/divmodqi4.S",
+	"avr/mulhi3.S",
+	"avr/mulqi3.S",
+	"avr/udivmodhi4.S",
+	"avr/udivmodqi4.S",
+}
+
 // CompilerRT 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.
@@ -181,11 +190,14 @@ var CompilerRT = Library{
 		// Development build.
 		return filepath.Join(goenv.Get("TINYGOROOT"), "lib/compiler-rt-builtins")
 	},
-	librarySources: func(target string) []string {
+	librarySources: func(target string) ([]string, error) {
 		builtins := append([]string{}, genericBuiltins...) // copy genericBuiltins
 		if strings.HasPrefix(target, "arm") || strings.HasPrefix(target, "thumb") {
 			builtins = append(builtins, aeabiBuiltins...)
 		}
-		return builtins
+		if strings.HasPrefix(target, "avr") {
+			builtins = append(builtins, avrBuiltins...)
+		}
+		return builtins, nil
 	},
 }

builder/cc1as.cpp

@@ -1,4 +1,4 @@
-// +build byollvm
+//go:build byollvm
 
 //===-- cc1as.cpp - Clang Assembler  --------------------------------------===//
 //
@@ -101,6 +101,9 @@ bool AssemblerInvocation::CreateFromArgs(AssemblerInvocation &Opts,
 
   // Target Options
   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());
+
   Opts.CPU = std::string(Args.getLastArgValue(OPT_target_cpu));
   Opts.Features = Args.getAllArgValues(OPT_target_feature);
 
@@ -203,6 +206,14 @@ bool AssemblerInvocation::CreateFromArgs(AssemblerInvocation &Opts,
                             .Default(0);
   }
 
+  if (auto *A = Args.getLastArg(OPT_femit_dwarf_unwind_EQ)) {
+    Opts.EmitDwarfUnwind =
+        llvm::StringSwitch<EmitDwarfUnwindType>(A->getValue())
+            .Case("always", EmitDwarfUnwindType::Always)
+            .Case("no-compact-unwind", EmitDwarfUnwindType::NoCompactUnwind)
+            .Case("default", EmitDwarfUnwindType::Default);
+  }
+
   return Success;
 }
 
@@ -253,6 +264,8 @@ static bool ExecuteAssemblerImpl(AssemblerInvocation &Opts,
   assert(MRI && "Unable to create target register info!");
 
   MCTargetOptions MCOptions;
+  MCOptions.EmitDwarfUnwind = Opts.EmitDwarfUnwind;
+
   std::unique_ptr<MCAsmInfo> MAI(
       TheTarget->createMCAsmInfo(*MRI, Opts.Triple, MCOptions));
   assert(MAI && "Unable to create target asm info!");
@@ -299,6 +312,8 @@ 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);
   Ctx.setObjectFileInfo(MOFI.get());
 
   if (Opts.SaveTemporaryLabels)
@@ -347,7 +362,7 @@ static bool ExecuteAssemblerImpl(AssemblerInvocation &Opts,
 
     std::unique_ptr<MCCodeEmitter> CE;
     if (Opts.ShowEncoding)
-      CE.reset(TheTarget->createMCCodeEmitter(*MCII, *MRI, Ctx));
+      CE.reset(TheTarget->createMCCodeEmitter(*MCII, Ctx));
     std::unique_ptr<MCAsmBackend> MAB(
         TheTarget->createMCAsmBackend(*STI, *MRI, MCOptions));
 
@@ -367,7 +382,7 @@ static bool ExecuteAssemblerImpl(AssemblerInvocation &Opts,
     }
 
     std::unique_ptr<MCCodeEmitter> CE(
-        TheTarget->createMCCodeEmitter(*MCII, *MRI, Ctx));
+        TheTarget->createMCCodeEmitter(*MCII, Ctx));
     std::unique_ptr<MCAsmBackend> MAB(
         TheTarget->createMCAsmBackend(*STI, *MRI, MCOptions));
     assert(MAB && "Unable to create asm backend!");
@@ -389,7 +404,7 @@ static bool ExecuteAssemblerImpl(AssemblerInvocation &Opts,
   if (Opts.EmbedBitcode && Ctx.getObjectFileType() == MCContext::IsMachO) {
     MCSection *AsmLabel = Ctx.getMachOSection(
         "__LLVM", "__asm", MachO::S_REGULAR, 4, SectionKind::getReadOnly());
-    Str.get()->SwitchSection(AsmLabel);
+    Str.get()->switchSection(AsmLabel);
     Str.get()->emitZeros(1);
   }
 

builder/cc1as.h

@@ -85,6 +85,9 @@ struct AssemblerInvocation {
   unsigned IncrementalLinkerCompatible : 1;
   unsigned EmbedBitcode : 1;
 
+  /// Whether to emit DWARF unwind info.
+  EmitDwarfUnwindType EmitDwarfUnwind;
+
   /// The name of the relocation model to use.
   std::string RelocationModel;
 
@@ -92,6 +95,9 @@ struct AssemblerInvocation {
   /// otherwise.
   std::string TargetABI;
 
+  /// Darwin target variant triple, the variant of the deployment target
+  /// for which the code is being compiled.
+  llvm::Optional<llvm::Triple> DarwinTargetVariantTriple;
   /// @}
 
 public:
@@ -112,6 +118,7 @@ public:
     Dwarf64 = 0;
     DwarfVersion = 0;
     EmbedBitcode = 0;
+    EmitDwarfUnwind = EmitDwarfUnwindType::Default;
   }
 
   static bool CreateFromArgs(AssemblerInvocation &Res,

builder/clang.cpp

@@ -1,4 +1,4 @@
-// +build byollvm
+//go:build byollvm
 
 #include <clang/Basic/DiagnosticOptions.h>
 #include <clang/CodeGen/CodeGenAction.h>

builder/config.go

@@ -33,8 +33,8 @@ func NewConfig(options *compileopts.Options) (*compileopts.Config, error) {
 	if err != nil {
 		return nil, fmt.Errorf("could not read version from GOROOT (%v): %v", goroot, err)
 	}
-	if major != 1 || minor < 18 || minor > 19 {
+	if major != 1 || minor < 18 || minor > 20 {
-		return nil, fmt.Errorf("requires go version 1.18 through 1.19, got go%d.%d", major, minor)
+		return nil, fmt.Errorf("requires go version 1.18 through 1.20, got go%d.%d", major, minor)
 	}
 
 	clangHeaderPath := getClangHeaderPath(goenv.Get("TINYGOROOT"))

builder/library.go

@@ -29,7 +29,7 @@ type Library struct {
 	sourceDir func() string
 
 	// The source files, relative to sourceDir.
-	librarySources func(target string) []string
+	librarySources func(target string) ([]string, error)
 
 	// The source code for the crt1.o file, relative to sourceDir.
 	crt1Source string
@@ -142,7 +142,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", "-g", "-ffunction-sections", "-fdata-sections", "-Wno-macro-redefined", "--target="+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)
 	cpu := config.CPU()
 	if cpu != "" {
 		// X86 has deprecated the -mcpu flag, so we need to use -march instead.
@@ -155,6 +155,9 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 			args = append(args, "-mcpu="+cpu)
 		}
 	}
+	if config.ABI() != "" {
+		args = append(args, "-mabi="+config.ABI())
+	}
 	if strings.HasPrefix(target, "arm") || strings.HasPrefix(target, "thumb") {
 		if strings.Split(target, "-")[2] == "linux" {
 			args = append(args, "-fno-unwind-tables", "-fno-asynchronous-unwind-tables")
@@ -170,10 +173,10 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 		args = append(args, "-mdouble=64")
 	}
 	if strings.HasPrefix(target, "riscv32-") {
-		args = append(args, "-march=rv32imac", "-mabi=ilp32", "-fforce-enable-int128")
+		args = append(args, "-march=rv32imac", "-fforce-enable-int128")
 	}
 	if strings.HasPrefix(target, "riscv64-") {
-		args = append(args, "-march=rv64gc", "-mabi=lp64")
+		args = append(args, "-march=rv64gc")
 	}
 	if strings.HasPrefix(target, "xtensa") {
 		// Hack to work around an issue in the Xtensa port:
@@ -219,7 +222,11 @@ 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.
-	for _, path := range l.librarySources(target) {
+	paths, err := l.librarySources(target)
+	if err != nil {
+		return nil, nil, err
+	}
+	for _, path := range paths {
 		// Strip leading "../" parts off the path.
 		cleanpath := path
 		for strings.HasPrefix(cleanpath, "../") {
@@ -235,6 +242,9 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 				var compileArgs []string
 				compileArgs = append(compileArgs, args...)
 				compileArgs = append(compileArgs, "-o", objpath, srcpath)
+				if config.Options.PrintCommands != nil {
+					config.Options.PrintCommands("clang", compileArgs...)
+				}
 				err := runCCompiler(compileArgs...)
 				if err != nil {
 					return &commandError{"failed to build", srcpath, err}
@@ -261,6 +271,9 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 				}
 				tmpfile.Close()
 				compileArgs = append(compileArgs, "-o", tmpfile.Name(), srcpath)
+				if config.Options.PrintCommands != nil {
+					config.Options.PrintCommands("clang", compileArgs...)
+				}
 				err = runCCompiler(compileArgs...)
 				if err != nil {
 					return &commandError{"failed to build", srcpath, err}

builder/lld.cpp

@@ -1,4 +1,4 @@
-// +build byollvm
+//go:build byollvm
 
 // This file provides C wrappers for liblld.
 

builder/mingw-w64.go

@@ -1,6 +1,7 @@
 package builder
 
 import (
+	"fmt"
 	"io"
 	"os"
 	"path/filepath"
@@ -31,9 +32,9 @@ var MinGW = Library{
 		// No flags necessary because there are no files to compile.
 		return nil
 	},
-	librarySources: func(target string) []string {
+	librarySources: func(target string) ([]string, error) {
 		// We only use the UCRT DLL file. No source files necessary.
-		return nil
+		return nil, nil
 	},
 }
 
@@ -43,7 +44,7 @@ var MinGW = Library{
 //
 // TODO: cache the result. At the moment, it costs a few hundred milliseconds to
 // compile these files.
-func makeMinGWExtraLibs(tmpdir string) []*compileJob {
+func makeMinGWExtraLibs(tmpdir, goarch string) []*compileJob {
 	var jobs []*compileJob
 	root := goenv.Get("TINYGOROOT")
 	// Normally all the api-ms-win-crt-*.def files are all compiled to a single
@@ -52,7 +53,7 @@ func makeMinGWExtraLibs(tmpdir string) []*compileJob {
 	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",
+		"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",
@@ -74,16 +75,27 @@ func makeMinGWExtraLibs(tmpdir string) []*compileJob {
 			result:      outpath,
 			run: func(job *compileJob) error {
 				defpath := inpath
+				var archDef, emulation string
+				switch goarch {
+				case "amd64":
+					archDef = "-DDEF_X64"
+					emulation = "i386pep"
+				case "arm64":
+					archDef = "-DDEF_ARM64"
+					emulation = "arm64pe"
+				default:
+					return fmt.Errorf("unsupported architecture for mingw-w64: %s", goarch)
+				}
 				if strings.HasSuffix(inpath, ".in") {
 					// .in files need to be preprocessed by a preprocessor (-E)
 					// first.
 					defpath = outpath + ".def"
-					err := runCCompiler("-E", "-x", "c", "-Wp,-w", "-P", "-DDEF_X64", "-DDATA", "-o", defpath, inpath, "-I"+goenv.Get("TINYGOROOT")+"/lib/mingw-w64/mingw-w64-crt/def-include/")
+					err := runCCompiler("-E", "-x", "c", "-Wp,-w", "-P", archDef, "-DDATA", "-o", defpath, inpath, "-I"+goenv.Get("TINYGOROOT")+"/lib/mingw-w64/mingw-w64-crt/def-include/")
 					if err != nil {
 						return err
 					}
 				}
-				return link("ld.lld", "-m", "i386pep", "-o", outpath, defpath)
+				return link("ld.lld", "-m", emulation, "-o", outpath, defpath)
 			},
 		}
 		jobs = append(jobs, job)

builder/musl.go

@@ -6,10 +6,12 @@ import (
 	"os"
 	"path/filepath"
 	"regexp"
+	"strconv"
 	"strings"
 
 	"github.com/tinygo-org/tinygo/compileopts"
 	"github.com/tinygo-org/tinygo/goenv"
+	"tinygo.org/x/go-llvm"
 )
 
 var Musl = Library{
@@ -77,7 +79,7 @@ var Musl = Library{
 	cflags: func(target, headerPath string) []string {
 		arch := compileopts.MuslArchitecture(target)
 		muslDir := filepath.Join(goenv.Get("TINYGOROOT"), "lib/musl")
-		return []string{
+		cflags := []string{
 			"-std=c99",            // same as in musl
 			"-D_XOPEN_SOURCE=700", // same as in musl
 			// Musl triggers some warnings and we don't want to show any
@@ -90,6 +92,7 @@ var Musl = Library{
 			"-Wno-ignored-attributes",
 			"-Wno-string-plus-int",
 			"-Wno-ignored-pragmas",
+			"-Wno-tautological-constant-out-of-range-compare",
 			"-Qunused-arguments",
 			// Select include dirs. Don't include standard library includes
 			// (that would introduce host dependencies and other complications),
@@ -103,9 +106,15 @@ var Musl = Library{
 			"-I" + muslDir + "/include",
 			"-fno-stack-protector",
 		}
+		llvmMajor, _ := strconv.Atoi(strings.SplitN(llvm.Version, ".", 2)[0])
+		if llvmMajor >= 15 {
+			// This flag was added in Clang 15. It is not present in LLVM 14.
+			cflags = append(cflags, "-Wno-deprecated-non-prototype")
+		}
+		return cflags
 	},
 	sourceDir: func() string { return filepath.Join(goenv.Get("TINYGOROOT"), "lib/musl/src") },
-	librarySources: func(target string) []string {
+	librarySources: func(target string) ([]string, error) {
 		arch := compileopts.MuslArchitecture(target)
 		globs := []string{
 			"env/*.c",
@@ -117,17 +126,21 @@ var Musl = Library{
 			"internal/vdso.c",
 			"legacy/*.c",
 			"malloc/*.c",
+			"malloc/mallocng/*.c",
 			"mman/*.c",
 			"math/*.c",
 			"signal/*.c",
 			"stdio/*.c",
 			"string/*.c",
 			"thread/" + arch + "/*.s",
-			"thread/" + arch + "/*.c",
 			"thread/*.c",
 			"time/*.c",
 			"unistd/*.c",
 		}
+		if arch == "arm" {
+			// These files need to be added to the start for some reason.
+			globs = append([]string{"thread/arm/*.c"}, globs...)
+		}
 
 		var sources []string
 		seenSources := map[string]struct{}{}
@@ -141,13 +154,16 @@ var Musl = Library{
 				// > ErrBadPattern, when pattern is malformed.
 				// So the only possible error is when the (statically defined)
 				// pattern is wrong. In other words, a programming bug.
-				panic("could not glob source dirs: " + err.Error())
+				return nil, fmt.Errorf("musl: could not glob source dirs: %w", err)
+			}
+			if len(matches) == 0 {
+				return nil, fmt.Errorf("musl: did not find any files for pattern %#v", pattern)
 			}
 			for _, match := range matches {
 				relpath, err := filepath.Rel(basepath, match)
 				if err != nil {
 					// Not sure if this is even possible.
-					panic(err)
+					return nil, err
 				}
 				// Make sure architecture specific files override generic files.
 				id := strings.ReplaceAll(relpath, "/"+arch+"/", "/")
@@ -159,7 +175,7 @@ var Musl = Library{
 				sources = append(sources, relpath)
 			}
 		}
-		return sources
+		return sources, nil
 	},
 	crt1Source: "../crt/crt1.c", // lib/musl/crt/crt1.c
 }

builder/picolibc.go

@@ -25,11 +25,13 @@ var Picolibc = Library{
 			"-Wall",
 			"-std=gnu11",
 			"-D_COMPILING_NEWLIB",
-			"-DHAVE_ALIAS_ATTRIBUTE",
+			"-D_HAVE_ALIAS_ATTRIBUTE",
 			"-DTINY_STDIO",
+			"-DPOSIX_IO",
 			"-D_IEEE_LIBM",
 			"-D__OBSOLETE_MATH_FLOAT=1", // use old math code that doesn't expect a FPU
 			"-D__OBSOLETE_MATH_DOUBLE=0",
+			"-D_WANT_IO_C99_FORMATS",
 			"-nostdlibinc",
 			"-isystem", newlibDir + "/libc/include",
 			"-I" + newlibDir + "/libc/tinystdio",
@@ -38,39 +40,30 @@ var Picolibc = Library{
 		}
 	},
 	sourceDir: func() string { return filepath.Join(goenv.Get("TINYGOROOT"), "lib/picolibc/newlib") },
-	librarySources: func(target string) []string {
+	librarySources: func(target string) ([]string, error) {
-		return picolibcSources
+		return picolibcSources, nil
 	},
 }
 
 var picolibcSources = []string{
 	"../../picolibc-stdio.c",
 
+	// srcs_tinystdio
 	"libc/tinystdio/asprintf.c",
-	"libc/tinystdio/atod_engine.c",
+	"libc/tinystdio/bufio.c",
-	"libc/tinystdio/atod_ryu.c",
-	"libc/tinystdio/atof_engine.c",
-	"libc/tinystdio/atof_ryu.c",
-	//"libc/tinystdio/atold_engine.c", // have_long_double and not long_double_equals_double
 	"libc/tinystdio/clearerr.c",
-	"libc/tinystdio/compare_exchange.c",
+	"libc/tinystdio/ecvt_r.c",
-	"libc/tinystdio/dtoa_data.c",
-	"libc/tinystdio/dtoa_engine.c",
-	"libc/tinystdio/dtoa_ryu.c",
-	"libc/tinystdio/ecvtbuf.c",
 	"libc/tinystdio/ecvt.c",
-	"libc/tinystdio/ecvt_data.c",
+	"libc/tinystdio/ecvtf_r.c",
-	"libc/tinystdio/ecvtfbuf.c",
 	"libc/tinystdio/ecvtf.c",
-	"libc/tinystdio/ecvtf_data.c",
-	"libc/tinystdio/exchange.c",
-	//"libc/tinystdio/fclose.c", // posix-io
-	"libc/tinystdio/fcvtbuf.c",
 	"libc/tinystdio/fcvt.c",
-	"libc/tinystdio/fcvtfbuf.c",
+	"libc/tinystdio/fcvt_r.c",
 	"libc/tinystdio/fcvtf.c",
+	"libc/tinystdio/fcvtf_r.c",
+	"libc/tinystdio/gcvt.c",
+	"libc/tinystdio/gcvtf.c",
+	"libc/tinystdio/fclose.c",
 	"libc/tinystdio/fdevopen.c",
-	//"libc/tinystdio/fdopen.c", // posix-io
 	"libc/tinystdio/feof.c",
 	"libc/tinystdio/ferror.c",
 	"libc/tinystdio/fflush.c",
@@ -78,70 +71,60 @@ var picolibcSources = []string{
 	"libc/tinystdio/fgets.c",
 	"libc/tinystdio/fileno.c",
 	"libc/tinystdio/filestrget.c",
-	"libc/tinystdio/filestrputalloc.c",
 	"libc/tinystdio/filestrput.c",
-	//"libc/tinystdio/fopen.c", // posix-io
+	"libc/tinystdio/filestrputalloc.c",
+	"libc/tinystdio/fmemopen.c",
 	"libc/tinystdio/fprintf.c",
 	"libc/tinystdio/fputc.c",
 	"libc/tinystdio/fputs.c",
 	"libc/tinystdio/fread.c",
+	//"libc/tinystdio/freopen.c", // crashes with AVR, see: https://github.com/picolibc/picolibc/pull/369
 	"libc/tinystdio/fscanf.c",
 	"libc/tinystdio/fseek.c",
+	"libc/tinystdio/fseeko.c",
 	"libc/tinystdio/ftell.c",
-	"libc/tinystdio/ftoa_data.c",
+	"libc/tinystdio/ftello.c",
-	"libc/tinystdio/ftoa_engine.c",
-	"libc/tinystdio/ftoa_ryu.c",
 	"libc/tinystdio/fwrite.c",
-	"libc/tinystdio/gcvtbuf.c",
-	"libc/tinystdio/gcvt.c",
-	"libc/tinystdio/gcvtfbuf.c",
-	"libc/tinystdio/gcvtf.c",
 	"libc/tinystdio/getchar.c",
 	"libc/tinystdio/gets.c",
 	"libc/tinystdio/matchcaseprefix.c",
+	"libc/tinystdio/mktemp.c",
 	"libc/tinystdio/perror.c",
-	//"libc/tinystdio/posixiob.c", // posix-io
-	//"libc/tinystdio/posixio.c", // posix-io
 	"libc/tinystdio/printf.c",
 	"libc/tinystdio/putchar.c",
 	"libc/tinystdio/puts.c",
-	"libc/tinystdio/ryu_divpow2.c",
+	"libc/tinystdio/rewind.c",
-	"libc/tinystdio/ryu_log10.c",
-	"libc/tinystdio/ryu_log2pow5.c",
-	"libc/tinystdio/ryu_pow5bits.c",
-	"libc/tinystdio/ryu_table.c",
-	"libc/tinystdio/ryu_umul128.c",
 	"libc/tinystdio/scanf.c",
 	"libc/tinystdio/setbuf.c",
+	"libc/tinystdio/setbuffer.c",
+	"libc/tinystdio/setlinebuf.c",
 	"libc/tinystdio/setvbuf.c",
-	//"libc/tinystdio/sflags.c", // posix-io
 	"libc/tinystdio/snprintf.c",
+	"libc/tinystdio/sprintf.c",
 	"libc/tinystdio/snprintfd.c",
 	"libc/tinystdio/snprintff.c",
-	"libc/tinystdio/sprintf.c",
-	"libc/tinystdio/sprintfd.c",
 	"libc/tinystdio/sprintff.c",
+	"libc/tinystdio/sprintfd.c",
 	"libc/tinystdio/sscanf.c",
-	"libc/tinystdio/strfromd.c",
 	"libc/tinystdio/strfromf.c",
+	"libc/tinystdio/strfromd.c",
+	"libc/tinystdio/strtof.c",
+	"libc/tinystdio/strtof_l.c",
 	"libc/tinystdio/strtod.c",
 	"libc/tinystdio/strtod_l.c",
-	"libc/tinystdio/strtof.c",
-	//"libc/tinystdio/strtold.c",   // have_long_double and not long_double_equals_double
-	//"libc/tinystdio/strtold_l.c", // have_long_double and not long_double_equals_double
 	"libc/tinystdio/ungetc.c",
 	"libc/tinystdio/vasprintf.c",
 	"libc/tinystdio/vfiprintf.c",
-	"libc/tinystdio/vfiscanf.c",
 	"libc/tinystdio/vfprintf.c",
 	"libc/tinystdio/vfprintff.c",
 	"libc/tinystdio/vfscanf.c",
+	"libc/tinystdio/vfiscanf.c",
 	"libc/tinystdio/vfscanff.c",
 	"libc/tinystdio/vprintf.c",
 	"libc/tinystdio/vscanf.c",
+	"libc/tinystdio/vsscanf.c",
 	"libc/tinystdio/vsnprintf.c",
 	"libc/tinystdio/vsprintf.c",
-	"libc/tinystdio/vsscanf.c",
 
 	"libc/string/bcmp.c",
 	"libc/string/bcopy.c",
@@ -300,6 +283,7 @@ var picolibcSources = []string{
 	"libm/common/s_expm1.c",
 	"libm/common/s_ilogb.c",
 	"libm/common/s_infinity.c",
+	"libm/common/s_iseqsig.c",
 	"libm/common/s_isinf.c",
 	"libm/common/s_isinfd.c",
 	"libm/common/s_isnan.c",
@@ -317,6 +301,7 @@ var picolibcSources = []string{
 	"libm/common/s_fmax.c",
 	"libm/common/s_fmin.c",
 	"libm/common/s_fpclassify.c",
+	"libm/common/s_getpayload.c",
 	"libm/common/s_lrint.c",
 	"libm/common/s_llrint.c",
 	"libm/common/s_lround.c",
@@ -331,7 +316,6 @@ var picolibcSources = []string{
 	"libm/common/exp2.c",
 	"libm/common/exp_data.c",
 	"libm/common/math_err_with_errno.c",
-	"libm/common/math_err_xflow.c",
 	"libm/common/math_err_uflow.c",
 	"libm/common/math_err_oflow.c",
 	"libm/common/math_err_divzero.c",
@@ -339,6 +323,8 @@ var picolibcSources = []string{
 	"libm/common/math_err_may_uflow.c",
 	"libm/common/math_err_check_uflow.c",
 	"libm/common/math_err_check_oflow.c",
+	"libm/common/math_inexact.c",
+	"libm/common/math_inexactf.c",
 	"libm/common/log.c",
 	"libm/common/log_data.c",
 	"libm/common/log2.c",
@@ -346,76 +332,91 @@ var picolibcSources = []string{
 	"libm/common/pow.c",
 	"libm/common/pow_log_data.c",
 
-	"libm/math/e_acos.c",
+	"libm/math/k_cos.c",
-	"libm/math/e_acosh.c",
+	"libm/math/k_rem_pio2.c",
-	"libm/math/e_asin.c",
+	"libm/math/k_sin.c",
-	"libm/math/e_atan2.c",
+	"libm/math/k_tan.c",
-	"libm/math/e_atanh.c",
+	"libm/math/kf_cos.c",
-	"libm/math/e_cosh.c",
+	"libm/math/kf_rem_pio2.c",
-	"libm/math/e_exp.c",
+	"libm/math/kf_sin.c",
-	"libm/math/ef_acos.c",
+	"libm/math/kf_tan.c",
-	"libm/math/ef_acosh.c",
+	"libm/math/s_acos.c",
-	"libm/math/ef_asin.c",
+	"libm/math/s_acosh.c",
-	"libm/math/ef_atan2.c",
+	"libm/math/s_asin.c",
-	"libm/math/ef_atanh.c",
-	"libm/math/ef_cosh.c",
-	"libm/math/ef_exp.c",
-	"libm/math/ef_fmod.c",
-	"libm/math/ef_hypot.c",
-	"libm/math/ef_j0.c",
-	"libm/math/ef_j1.c",
-	"libm/math/ef_jn.c",
-	"libm/math/ef_lgamma.c",
-	"libm/math/ef_log10.c",
-	"libm/math/ef_log.c",
-	"libm/math/e_fmod.c",
-	"libm/math/ef_pow.c",
-	"libm/math/ef_remainder.c",
-	"libm/math/ef_rem_pio2.c",
-	"libm/math/ef_scalb.c",
-	"libm/math/ef_sinh.c",
-	"libm/math/ef_sqrt.c",
-	"libm/math/ef_tgamma.c",
-	"libm/math/e_hypot.c",
-	"libm/math/e_j0.c",
-	"libm/math/e_j1.c",
-	"libm/math/e_jn.c",
-	"libm/math/e_lgamma.c",
-	"libm/math/e_log10.c",
-	"libm/math/e_log.c",
-	"libm/math/e_pow.c",
-	"libm/math/e_remainder.c",
-	"libm/math/e_rem_pio2.c",
-	"libm/math/erf_lgamma.c",
-	"libm/math/er_lgamma.c",
-	"libm/math/e_scalb.c",
-	"libm/math/e_sinh.c",
-	"libm/math/e_sqrt.c",
-	"libm/math/e_tgamma.c",
 	"libm/math/s_asinh.c",
 	"libm/math/s_atan.c",
+	"libm/math/s_atan2.c",
+	"libm/math/s_atanh.c",
 	"libm/math/s_ceil.c",
 	"libm/math/s_cos.c",
+	"libm/math/s_cosh.c",
+	"libm/math/s_drem.c",
 	"libm/math/s_erf.c",
+	"libm/math/s_exp.c",
+	"libm/math/s_exp2.c",
 	"libm/math/s_fabs.c",
-	"libm/math/sf_asinh.c",
-	"libm/math/sf_atan.c",
-	"libm/math/sf_ceil.c",
-	"libm/math/sf_cos.c",
-	"libm/math/sf_erf.c",
-	"libm/math/sf_fabs.c",
-	"libm/math/sf_floor.c",
-	"libm/math/sf_frexp.c",
-	"libm/math/sf_ldexp.c",
 	"libm/math/s_floor.c",
+	"libm/math/s_fmod.c",
 	"libm/math/s_frexp.c",
-	"libm/math/sf_signif.c",
+	"libm/math/s_gamma.c",
-	"libm/math/sf_sin.c",
+	"libm/math/s_hypot.c",
-	"libm/math/sf_tan.c",
+	"libm/math/s_j0.c",
-	"libm/math/sf_tanh.c",
+	"libm/math/s_j1.c",
-	"libm/math/s_ldexp.c",
+	"libm/math/s_jn.c",
+	"libm/math/s_lgamma.c",
+	"libm/math/s_log.c",
+	"libm/math/s_log10.c",
+	"libm/math/s_pow.c",
+	"libm/math/s_rem_pio2.c",
+	"libm/math/s_remainder.c",
+	"libm/math/s_scalb.c",
 	"libm/math/s_signif.c",
 	"libm/math/s_sin.c",
+	"libm/math/s_sincos.c",
+	"libm/math/s_sinh.c",
+	"libm/math/s_sqrt.c",
 	"libm/math/s_tan.c",
 	"libm/math/s_tanh.c",
+	"libm/math/s_tgamma.c",
+	"libm/math/sf_acos.c",
+	"libm/math/sf_acosh.c",
+	"libm/math/sf_asin.c",
+	"libm/math/sf_asinh.c",
+	"libm/math/sf_atan.c",
+	"libm/math/sf_atan2.c",
+	"libm/math/sf_atanh.c",
+	"libm/math/sf_ceil.c",
+	"libm/math/sf_cos.c",
+	"libm/math/sf_cosh.c",
+	"libm/math/sf_drem.c",
+	"libm/math/sf_erf.c",
+	"libm/math/sf_exp.c",
+	"libm/math/sf_exp2.c",
+	"libm/math/sf_fabs.c",
+	"libm/math/sf_floor.c",
+	"libm/math/sf_fmod.c",
+	"libm/math/sf_frexp.c",
+	"libm/math/sf_gamma.c",
+	"libm/math/sf_hypot.c",
+	"libm/math/sf_j0.c",
+	"libm/math/sf_j1.c",
+	"libm/math/sf_jn.c",
+	"libm/math/sf_lgamma.c",
+	"libm/math/sf_log.c",
+	"libm/math/sf_log10.c",
+	"libm/math/sf_log2.c",
+	"libm/math/sf_pow.c",
+	"libm/math/sf_rem_pio2.c",
+	"libm/math/sf_remainder.c",
+	"libm/math/sf_scalb.c",
+	"libm/math/sf_signif.c",
+	"libm/math/sf_sin.c",
+	"libm/math/sf_sincos.c",
+	"libm/math/sf_sinh.c",
+	"libm/math/sf_sqrt.c",
+	"libm/math/sf_tan.c",
+	"libm/math/sf_tanh.c",
+	"libm/math/sf_tgamma.c",
+	"libm/math/sr_lgamma.c",
+	"libm/math/srf_lgamma.c",
 }

builder/tools-builtin.go

@@ -1,5 +1,4 @@
 //go:build byollvm
-// +build byollvm
 
 package builder
 
@@ -29,7 +28,7 @@ const hasBuiltinTools = true
 func RunTool(tool string, args ...string) error {
 	linker := "elf"
 	if tool == "ld.lld" && len(args) >= 2 {
-		if args[0] == "-m" && args[1] == "i386pep" {
+		if args[0] == "-m" && (args[1] == "i386pep" || args[1] == "arm64pe") {
 			linker = "mingw"
 		} else if args[0] == "-flavor" {
 			linker = args[1]

builder/tools-external.go

@@ -1,5 +1,4 @@
 //go:build !byollvm
-// +build !byollvm
 
 package builder
 

cgo/cgo.go

@@ -86,6 +86,8 @@ var cgoAliases = map[string]string{
 	"C.uint32_t":  "uint32",
 	"C.uint64_t":  "uint64",
 	"C.uintptr_t": "uintptr",
+	"C.float":     "float32",
+	"C.double":    "float64",
 }
 
 // builtinAliases are handled specially because they only exist on the Go side
@@ -309,6 +311,12 @@ func Process(files []*ast.File, dir, importPath string, fset *token.FileSet, cfl
 	// Process CGo imports for each file.
 	for i, f := range files {
 		cf := p.newCGoFile(f, i)
+		// Float and double are aliased, meaning that C.float is the same thing
+		// as float32 in Go.
+		cf.names["float"] = clangCursor{}
+		cf.names["double"] = clangCursor{}
+		// Now read all the names (identifies) that C defines in the header
+		// snippet.
 		cf.readNames(p.cgoHeaders[i], cflagsForCGo, filepath.Base(fset.File(f.Pos()).Name()), func(names map[string]clangCursor) {
 			for _, name := range builtinAliases {
 				// Names such as C.int should not be obtained from C.
@@ -948,6 +956,9 @@ func (p *cgoPackage) isEquivalentAST(a, b ast.Node) bool {
 		if !ok {
 			return false
 		}
+		if node == nil || b == nil {
+			return node == b
+		}
 		if len(node.List) != len(b.List) {
 			return false
 		}

cgo/cgo_test.go

@@ -11,6 +11,7 @@ import (
 	"go/types"
 	"os"
 	"path/filepath"
+	"regexp"
 	"runtime"
 	"strings"
 	"testing"
@@ -21,9 +22,15 @@ var flagUpdate = flag.Bool("update", false, "Update images based on test output.
 
 // normalizeResult normalizes Go source code that comes out of tests across
 // platforms and Go versions.
-func normalizeResult(result string) string {
+func normalizeResult(t *testing.T, result string) string {
-	actual := strings.ReplaceAll(result, "\r\n", "\n")
+	result = strings.ReplaceAll(result, "\r\n", "\n")
-	return actual
+
+	// This changed to 'undefined:', in Go 1.20.
+	result = strings.ReplaceAll(result, ": undeclared name:", ": undefined:")
+	// Go 1.20 added a bit more detail
+	result = regexp.MustCompile(`(unknown field z in struct literal).*`).ReplaceAllString(result, "$1")
+
+	return result
 }
 
 func TestCGo(t *testing.T) {
@@ -88,7 +95,7 @@ func TestCGo(t *testing.T) {
 			if err != nil {
 				t.Errorf("could not write out CGo AST: %v", err)
 			}
-			actual := normalizeResult(buf.String())
+			actual := normalizeResult(t, buf.String())
 
 			// Read the file with the expected output, to compare against.
 			outfile := filepath.Join("testdata", name+".out.go")
@@ -115,6 +122,84 @@ func TestCGo(t *testing.T) {
 	}
 }
 
+func Test_cgoPackage_isEquivalentAST(t *testing.T) {
+	fieldA := &ast.Field{Type: &ast.BasicLit{Kind: token.STRING, Value: "a"}}
+	fieldB := &ast.Field{Type: &ast.BasicLit{Kind: token.STRING, Value: "b"}}
+	listOfFieldA := &ast.FieldList{List: []*ast.Field{fieldA}}
+	listOfFieldB := &ast.FieldList{List: []*ast.Field{fieldB}}
+	funcDeclA := &ast.FuncDecl{Name: &ast.Ident{Name: "a"}, Type: &ast.FuncType{Params: &ast.FieldList{}, Results: listOfFieldA}}
+	funcDeclB := &ast.FuncDecl{Name: &ast.Ident{Name: "b"}, Type: &ast.FuncType{Params: &ast.FieldList{}, Results: listOfFieldB}}
+	funcDeclNoResults := &ast.FuncDecl{Name: &ast.Ident{Name: "C"}, Type: &ast.FuncType{Params: &ast.FieldList{}}}
+
+	testCases := []struct {
+		name     string
+		a, b     ast.Node
+		expected bool
+	}{
+		{
+			name:     "both nil",
+			expected: true,
+		},
+		{
+			name:     "not same type",
+			a:        fieldA,
+			b:        &ast.FuncDecl{},
+			expected: false,
+		},
+		{
+			name:     "Field same",
+			a:        fieldA,
+			b:        fieldA,
+			expected: true,
+		},
+		{
+			name:     "Field different",
+			a:        fieldA,
+			b:        fieldB,
+			expected: false,
+		},
+		{
+			name:     "FuncDecl Type Results nil",
+			a:        funcDeclNoResults,
+			b:        funcDeclNoResults,
+			expected: true,
+		},
+		{
+			name:     "FuncDecl Type Results same",
+			a:        funcDeclA,
+			b:        funcDeclA,
+			expected: true,
+		},
+		{
+			name:     "FuncDecl Type Results different",
+			a:        funcDeclA,
+			b:        funcDeclB,
+			expected: false,
+		},
+		{
+			name:     "FuncDecl Type Results a nil",
+			a:        funcDeclNoResults,
+			b:        funcDeclB,
+			expected: false,
+		},
+		{
+			name:     "FuncDecl Type Results b nil",
+			a:        funcDeclA,
+			b:        funcDeclNoResults,
+			expected: false,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			p := &cgoPackage{}
+			if got := p.isEquivalentAST(tc.a, tc.b); tc.expected != got {
+				t.Errorf("expected %v, got %v", tc.expected, got)
+			}
+		})
+	}
+}
+
 // simpleImporter implements the types.Importer interface, but only allows
 // importing the unsafe package.
 type simpleImporter struct {

cgo/const.go

@@ -14,6 +14,9 @@ import (
 var (
 	prefixParseFns map[token.Token]func(*tokenizer) (ast.Expr, *scanner.Error)
 	precedences    = map[token.Token]int{
+		token.OR:  precedenceOr,
+		token.XOR: precedenceXor,
+		token.AND: precedenceAnd,
 		token.ADD: precedenceAdd,
 		token.SUB: precedenceAdd,
 		token.MUL: precedenceMul,
@@ -24,6 +27,9 @@ var (
 
 const (
 	precedenceLowest = iota + 1
+	precedenceOr
+	precedenceXor
+	precedenceAnd
 	precedenceAdd
 	precedenceMul
 	precedencePrefix
@@ -76,7 +82,7 @@ func parseConstExpr(t *tokenizer, precedence int) (ast.Expr, *scanner.Error) {
 
 	for t.peekToken != token.EOF && precedence < precedences[t.peekToken] {
 		switch t.peekToken {
-		case token.ADD, token.SUB, token.MUL, token.QUO, token.REM:
+		case token.OR, token.XOR, token.AND, token.ADD, token.SUB, token.MUL, token.QUO, token.REM:
 			t.Next()
 			leftExpr, err = parseBinaryExpr(t, leftExpr)
 		}
@@ -199,7 +205,18 @@ func (t *tokenizer) Next() {
 			// https://en.cppreference.com/w/cpp/string/byte/isspace
 			t.peekPos++
 			t.buf = t.buf[1:]
-		case c == '(' || c == ')' || c == '+' || c == '-' || c == '*' || c == '/' || c == '%':
+		case len(t.buf) >= 2 && (string(t.buf[:2]) == "||" || string(t.buf[:2]) == "&&"):
+			// Two-character tokens.
+			switch c {
+			case '&':
+				t.peekToken = token.LAND
+			case '|':
+				t.peekToken = token.LOR
+			}
+			t.peekValue = t.buf[:2]
+			t.buf = t.buf[2:]
+			return
+		case c == '(' || c == ')' || c == '+' || c == '-' || c == '*' || c == '/' || c == '%' || c == '&' || c == '|' || c == '^':
 			// Single-character tokens.
 			// TODO: ++ (increment) and -- (decrement) operators.
 			switch c {
@@ -217,6 +234,12 @@ func (t *tokenizer) Next() {
 				t.peekToken = token.QUO
 			case '%':
 				t.peekToken = token.REM
+			case '&':
+				t.peekToken = token.AND
+			case '|':
+				t.peekToken = token.OR
+			case '^':
+				t.peekToken = token.XOR
 			}
 			t.peekValue = t.buf[:1]
 			t.buf = t.buf[1:]

cgo/const_test.go

@@ -37,6 +37,10 @@ func TestParseConst(t *testing.T) {
 		{`5*5`, `5 * 5`},
 		{`5/5`, `5 / 5`},
 		{`5%5`, `5 % 5`},
+		{`5&5`, `5 & 5`},
+		{`5|5`, `5 | 5`},
+		{`5^5`, `5 ^ 5`},
+		{`5||5`, `error: 1:2: unexpected token ||, expected end of expression`}, // logical binops aren't supported yet
 		{`(5/5)`, `(5 / 5)`},
 		{`1 - 2`, `1 - 2`},
 		{`1 - 2 + 3`, `1 - 2 + 3`},

cgo/libclang.go

@@ -533,6 +533,26 @@ func tinygo_clang_globals_visitor(c, parent C.GoCXCursor, client_data C.CXClient
 	return C.CXChildVisit_Continue
 }
 
+// Get the precise location in the source code. Used for uniquely identifying
+// source locations.
+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
+	var column C.unsigned
+	C.clang_getFileLocation(clangLocation, &file, &line, &column, nil)
+	location := token.Position{
+		Filename: getString(C.clang_getFileName(file)),
+		Line:     int(line),
+		Column:   int(column),
+	}
+	if location.Filename == "" || location.Line == 0 {
+		// Not sure when this would happen, but protect from it anyway.
+		f.addError(pos, "could not find file/line information")
+	}
+	return location
+}
+
 // getCursorPosition returns a usable token.Pos from a libclang cursor.
 func (p *cgoPackage) getCursorPosition(cursor C.GoCXCursor) token.Pos {
 	return p.getClangLocationPosition(C.tinygo_clang_getCursorLocation(cursor), C.tinygo_clang_Cursor_getTranslationUnit(cursor))
@@ -788,20 +808,7 @@ func (f *cgoFile) makeASTType(typ C.CXType, pos token.Pos) ast.Expr {
 		}
 		if name == "" {
 			// Anonymous record, probably inside a typedef.
-			clangLocation := C.tinygo_clang_getCursorLocation(cursor)
+			location := f.getUniqueLocationID(pos, cursor)
-			var file C.CXFile
-			var line C.unsigned
-			var column C.unsigned
-			C.clang_getFileLocation(clangLocation, &file, &line, &column, nil)
-			location := token.Position{
-				Filename: getString(C.clang_getFileName(file)),
-				Line:     int(line),
-				Column:   int(column),
-			}
-			if location.Filename == "" || location.Line == 0 {
-				// Not sure when this would happen, but protect from it anyway.
-				f.addError(pos, "could not find file/line information")
-			}
 			name = f.getUnnamedDeclName("_Ctype_"+cgoRecordPrefix+"__", location)
 		} else {
 			name = cgoRecordPrefix + name
@@ -814,7 +821,9 @@ func (f *cgoFile) makeASTType(typ C.CXType, pos token.Pos) ast.Expr {
 		cursor := C.tinygo_clang_getTypeDeclaration(typ)
 		name := getString(C.tinygo_clang_getCursorSpelling(cursor))
 		if name == "" {
-			name = f.getUnnamedDeclName("_Ctype_enum___", cursor)
+			// Anonymous enum, probably inside a typedef.
+			location := f.getUniqueLocationID(pos, cursor)
+			name = f.getUnnamedDeclName("_Ctype_enum___", location)
 		} else {
 			name = "enum_" + name
 		}

cgo/libclang_config_llvm14.go

@@ -1,5 +1,4 @@
-//go:build !byollvm
+//go:build !byollvm && llvm14
-// +build !byollvm
 
 package cgo
 

cgo/libclang_config_llvm15.go

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

cgo/testdata/errors.out.go

@@ -8,9 +8,9 @@
 // Type checking errors after CGo processing:
 //     testdata/errors.go:102: cannot use 2 << 10 (untyped int constant 2048) as C.char value in variable declaration (overflows)
 //     testdata/errors.go:105: unknown field z in struct literal
-//     testdata/errors.go:108: undeclared name: C.SOME_CONST_1
+//     testdata/errors.go: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: undeclared name: C.SOME_CONST_4
+//     testdata/errors.go:112: undefined: C.SOME_CONST_4
 
 package main
 

cgo/testdata/types.go

@@ -112,6 +112,10 @@ import "C"
 import "C"
 
 var (
+	// aliases
+	_ C.float
+	_ C.double
+
 	// Simple typedefs.
 	_ C.myint
 

compileopts/config.go

@@ -47,6 +47,12 @@ func (c *Config) Features() string {
 	return c.Target.Features + "," + c.Options.LLVMFeatures
 }
 
+// ABI returns the -mabi= flag for this target (like -mabi=lp64). A zero-length
+// string is returned if the target doesn't specify an ABI.
+func (c *Config) ABI() string {
+	return c.Target.ABI
+}
+
 // GOOS returns the GOOS of the target. This might not always be the actual OS:
 // for example, bare-metal targets will usually pretend to be linux to get the
 // standard library to compile.
@@ -84,7 +90,7 @@ func (c *Config) CgoEnabled() bool {
 }
 
 // GC returns the garbage collection strategy in use on this platform. Valid
-// values are "none", "leaking", and "conservative".
+// values are "none", "leaking", "conservative" and "precise".
 func (c *Config) GC() string {
 	if c.Options.GC != "" {
 		return c.Options.GC
@@ -99,7 +105,7 @@ func (c *Config) GC() string {
 // that can be traced by the garbage collector.
 func (c *Config) NeedsStackObjects() bool {
 	switch c.GC() {
-	case "conservative":
+	case "conservative", "custom", "precise":
 		for _, tag := range c.BuildTags() {
 			if tag == "tinygo.wasm" {
 				return true
@@ -184,22 +190,11 @@ func (c *Config) StackSize() uint64 {
 	return c.Target.DefaultStackSize
 }
 
-// UseThinLTO returns whether ThinLTO should be used for the given target. Some
+// UseThinLTO returns whether ThinLTO should be used for the given target.
-// targets (such as wasm) are not yet supported.
-// We should try and remove as many exceptions as possible in the future, so
-// that this optimization can be applied in more places.
 func (c *Config) UseThinLTO() bool {
-	parts := strings.Split(c.Triple(), "-")
+	// All architectures support ThinLTO now. However, this code is kept for the
-	if parts[0] == "wasm32" {
+	// time being in case there are regressions. The non-ThinLTO code support
-		// wasm-ld doesn't seem to support ThinLTO yet.
+	// should be removed when it is proven to work reliably.
-		return false
-	}
-	if parts[0] == "avr" || parts[0] == "xtensa" {
-		// These use external (GNU) linkers which might perhaps support ThinLTO
-		// through a plugin, but it's too much hassle to set up.
-		return false
-	}
-	// Other architectures support ThinLTO.
 	return true
 }
 
@@ -230,6 +225,9 @@ func (c *Config) LibcPath(name string) (path string, precompiled bool) {
 	if c.CPU() != "" {
 		archname += "-" + c.CPU()
 	}
+	if c.ABI() != "" {
+		archname += "-" + c.ABI()
+	}
 
 	// Try to load a precompiled library.
 	precompiledDir := filepath.Join(goenv.Get("TINYGOROOT"), "pkg", archname, name)
@@ -320,7 +318,7 @@ func (c *Config) CFlags() []string {
 		panic("unknown libc: " + c.Target.Libc)
 	}
 	// Always emit debug information. It is optionally stripped at link time.
-	cflags = append(cflags, "-g")
+	cflags = append(cflags, "-gdwarf-4")
 	// Use the same optimization level as TinyGo.
 	cflags = append(cflags, "-O"+c.Options.Opt)
 	// Set the LLVM target triple.
@@ -338,6 +336,10 @@ func (c *Config) CFlags() []string {
 			cflags = append(cflags, "-mcpu="+c.Target.CPU)
 		}
 	}
+	// Set the -mabi flag, if needed.
+	if c.ABI() != "" {
+		cflags = append(cflags, "-mabi="+c.ABI())
+	}
 	return cflags
 }
 
@@ -377,8 +379,8 @@ func (c *Config) VerifyIR() bool {
 }
 
 // Debug returns whether debug (DWARF) information should be retained by the
-// linker. By default, debug information is retained but it can be removed with
+// linker. By default, debug information is retained, but it can be removed
-// the -no-debug flag.
+// with the -no-debug flag.
 func (c *Config) Debug() bool {
 	return c.Options.Debug
 }
@@ -498,12 +500,8 @@ func (c *Config) RelocationModel() string {
 	return "static"
 }
 
-// WasmAbi returns the WASM ABI which is specified in the target JSON file, and
+// WasmAbi returns the WASM ABI which is specified in the target JSON file.
-// the value is overridden by `-wasm-abi` flag if it is provided
 func (c *Config) WasmAbi() string {
-	if c.Options.WasmAbi != "" {
-		return c.Options.WasmAbi
-	}
 	return c.Target.WasmAbi
 }
 
@@ -540,6 +538,8 @@ func (c *Config) Emulator(format, binary string) ([]string, error) {
 	var emulator []string
 	for _, s := range parts {
 		s = strings.ReplaceAll(s, "{root}", goenv.Get("TINYGOROOT"))
+		// Allow replacement of what's usually /tmp except notably Windows.
+		s = strings.ReplaceAll(s, "{tmpDir}", os.TempDir())
 		s = strings.ReplaceAll(s, "{"+format+"}", binary)
 		emulator = append(emulator, s)
 	}

compileopts/options.go

@@ -8,7 +8,7 @@ import (
 )
 
 var (
-	validGCOptions            = []string{"none", "leaking", "conservative"}
+	validGCOptions            = []string{"none", "leaking", "conservative", "custom", "precise"}
 	validSchedulerOptions     = []string{"none", "tasks", "asyncify"}
 	validSerialOptions        = []string{"none", "uart", "usb"}
 	validPrintSizeOptions     = []string{"none", "short", "full"}
@@ -42,7 +42,6 @@ type Options struct {
 	PrintAllocs     *regexp.Regexp // regexp string
 	PrintStacks     bool
 	Tags            []string
-	WasmAbi         string
 	GlobalValues    map[string]map[string]string // map[pkgpath]map[varname]value
 	TestConfig      TestConfig
 	Programmer      string
@@ -52,6 +51,7 @@ type Options struct {
 	PrintJSON       bool
 	Monitor         bool
 	BaudRate        int
+	Timeout         time.Duration
 }
 
 // Verify performs a validation on the given options, raising an error if options are not valid.

compileopts/options_test.go

@@ -9,7 +9,7 @@ import (
 
 func TestVerifyOptions(t *testing.T) {
 
-	expectedGCError := errors.New(`invalid gc option 'incorrect': valid values are none, leaking, conservative`)
+	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`)
 	expectedPanicStrategyError := errors.New(`invalid panic option 'incorrect': valid values are print, trap`)
@@ -48,6 +48,12 @@ func TestVerifyOptions(t *testing.T) {
 				GC: "conservative",
 			},
 		},
+		{
+			name: "GCOptionCustom",
+			opts: compileopts.Options{
+				GC: "custom",
+			},
+		},
 		{
 			name: "InvalidSchedulerOption",
 			opts: compileopts.Options{

compileopts/target.go

@@ -26,6 +26,7 @@ type TargetSpec struct {
 	Inherits         []string `json:"inherits"`
 	Triple           string   `json:"llvm-target"`
 	CPU              string   `json:"cpu"`
+	ABI              string   `json:"target-abi"` // rougly equivalent to -mabi= flag
 	Features         string   `json:"features"`
 	GOOS             string   `json:"goos"`
 	GOARCH           string   `json:"goarch"`
@@ -47,7 +48,7 @@ type TargetSpec struct {
 	FlashCommand     string   `json:"flash-command"`
 	GDB              []string `json:"gdb"`
 	PortReset        string   `json:"flash-1200-bps-reset"`
-	SerialPort       []string `json:"serial-port"` // serial port IDs in the form "acm:vid:pid" or "usb:vid:pid"
+	SerialPort       []string `json:"serial-port"` // serial port IDs in the form "vid:pid"
 	FlashMethod      string   `json:"flash-method"`
 	FlashVolume      string   `json:"msd-volume-name"`
 	FlashFilename    string   `json:"msd-firmware-name"`
@@ -194,6 +195,7 @@ func LoadTarget(options *Options) (*TargetSpec, error) {
 		default:
 			llvmarch = options.GOARCH
 		}
+		llvmvendor := "unknown"
 		llvmos := options.GOOS
 		if llvmos == "darwin" {
 			// Use macosx* instead of darwin, otherwise darwin/arm64 will refer
@@ -203,12 +205,14 @@ func LoadTarget(options *Options) (*TargetSpec, error) {
 				// Looks like Apple prefers to call this architecture ARM64
 				// instead of AArch64.
 				llvmarch = "arm64"
+				llvmos = "macosx11.0.0"
 			}
+			llvmvendor = "apple"
 		}
 		// Target triples (which actually have four components, but are called
 		// triples for historical reasons) have the form:
 		//   arch-vendor-os-environment
-		target := llvmarch + "-unknown-" + llvmos
+		target := llvmarch + "-" + llvmvendor + "-" + llvmos
 		if options.GOOS == "windows" {
 			target += "-gnu"
 		} else if options.GOARCH == "arm" {
@@ -246,6 +250,7 @@ func defaultTarget(goos, goarch, triple string) (*TargetSpec, error) {
 		GOOS:             goos,
 		GOARCH:           goarch,
 		BuildTags:        []string{goos, goarch},
+		GC:               "precise",
 		Scheduler:        "tasks",
 		Linker:           "cc",
 		DefaultStackSize: 1024 * 64, // 64kB
@@ -299,10 +304,19 @@ func defaultTarget(goos, goarch, triple string) (*TargetSpec, error) {
 		// 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 goarch {
+		case "amd64":
+			spec.LDFlags = append(spec.LDFlags,
+				"-m", "i386pep",
+				"--image-base", "0x400000",
+			)
+		case "arm64":
+			spec.LDFlags = append(spec.LDFlags,
+				"-m", "arm64pe",
+			)
+		}
 		spec.LDFlags = append(spec.LDFlags,
-			"-m", "i386pep",
 			"-Bdynamic",
-			"--image-base", "0x400000",
 			"--gc-sections",
 			"--no-insert-timestamp",
 			"--no-dynamicbase",

compiler/alias.go

@@ -52,7 +52,7 @@ func (b *builder) createAlias(alias llvm.Value) {
 		b.CreateUnreachable()
 		return
 	}
-	result := b.CreateCall(alias, b.llvmFn.Params(), "")
+	result := b.CreateCall(alias.GlobalValueType(), alias, b.llvmFn.Params(), "")
 	if result.Type().TypeKind() == llvm.VoidTypeKind {
 		b.CreateRetVoid()
 	} else {

compiler/asserts.go

@@ -89,10 +89,11 @@ func (b *builder) createSliceToArrayPointerCheck(sliceLen llvm.Value, arrayLen i
 	b.createRuntimeAssert(isLess, "slicetoarray", "sliceToArrayPointerPanic")
 }
 
-// createUnsafeSliceCheck inserts a runtime check used for unsafe.Slice. This
+// createUnsafeSliceStringCheck inserts a runtime check used for unsafe.Slice
-// function must panic if the ptr/len parameters are invalid.
+// and unsafe.String. This function must panic if the ptr/len parameters are
-func (b *builder) createUnsafeSliceCheck(ptr, len llvm.Value, lenType *types.Basic) {
+// invalid.
-	// From the documentation of unsafe.Slice:
+func (b *builder) createUnsafeSliceStringCheck(name string, ptr, len llvm.Value, elementType llvm.Type, lenType *types.Basic) {
+	// From the documentation of unsafe.Slice and unsafe.String:
 	//   > At run time, if len is negative, or if ptr is nil and len is not
 	//   > zero, a run-time panic occurs.
 	// However, in practice, it is also necessary to check that the length is
@@ -105,7 +106,7 @@ func (b *builder) createUnsafeSliceCheck(ptr, len llvm.Value, lenType *types.Bas
 
 	// Determine the maximum slice size, and therefore the maximum value of the
 	// len parameter.
-	maxSize := b.maxSliceSize(ptr.Type().ElementType())
+	maxSize := b.maxSliceSize(elementType)
 	maxSizeValue := llvm.ConstInt(len.Type(), maxSize, false)
 
 	// Do the check. By using unsigned greater than for the length check, signed
@@ -117,7 +118,7 @@ func (b *builder) createUnsafeSliceCheck(ptr, len llvm.Value, lenType *types.Bas
 	lenIsNotZero := b.CreateICmp(llvm.IntNE, len, zero, "")
 	assert := b.CreateAnd(ptrIsNil, lenIsNotZero, "")
 	assert = b.CreateOr(assert, lenOutOfBounds, "")
-	b.createRuntimeAssert(assert, "unsafe.Slice", "unsafeSlicePanic")
+	b.createRuntimeAssert(assert, name, "unsafeSlicePanic")
 }
 
 // createChanBoundsCheck creates a bounds check before creating a new channel to
@@ -145,7 +146,7 @@ func (b *builder) createChanBoundsCheck(elementSize uint64, bufSize llvm.Value,
 	}
 	// Make the maxBufSize actually the maximum allowed value (in number of
 	// elements in the channel buffer).
-	maxBufSize = llvm.ConstUDiv(maxBufSize, llvm.ConstInt(b.uintptrType, elementSize, false))
+	maxBufSize = b.CreateUDiv(maxBufSize, llvm.ConstInt(b.uintptrType, elementSize, false), "")
 
 	// Make sure maxBufSize has the same type as bufSize.
 	if maxBufSize.Type() != bufSize.Type() {

compiler/atomic.go

@@ -25,7 +25,7 @@ func (b *builder) createAtomicOp(name string) llvm.Value {
 			if fn.IsNil() {
 				fn = llvm.AddFunction(b.mod, name, llvm.FunctionType(vType, []llvm.Type{ptr.Type(), vType}, false))
 			}
-			oldVal := b.createCall(fn, []llvm.Value{ptr, val}, "")
+			oldVal := b.createCall(fn.GlobalValueType(), fn, []llvm.Value{ptr, val}, "")
 			// Return the new value, not the original value returned.
 			return b.CreateAdd(oldVal, val, "")
 		}
@@ -56,7 +56,7 @@ func (b *builder) createAtomicOp(name string) llvm.Value {
 		return swapped
 	case "LoadInt32", "LoadInt64", "LoadUint32", "LoadUint64", "LoadUintptr", "LoadPointer":
 		ptr := b.getValue(b.fn.Params[0])
-		val := b.CreateLoad(ptr, "")
+		val := b.CreateLoad(b.getLLVMType(b.fn.Signature.Results().At(0).Type()), ptr, "")
 		val.SetOrdering(llvm.AtomicOrderingSequentiallyConsistent)
 		val.SetAlignment(b.targetData.PrefTypeAlignment(val.Type())) // required
 		return val
@@ -78,7 +78,7 @@ func (b *builder) createAtomicOp(name string) llvm.Value {
 			if fn.IsNil() {
 				fn = llvm.AddFunction(b.mod, name, llvm.FunctionType(vType, []llvm.Type{ptr.Type(), vType, b.uintptrType}, false))
 			}
-			b.createCall(fn, []llvm.Value{ptr, val, llvm.ConstInt(b.uintptrType, 5, false)}, "")
+			b.createCall(fn.GlobalValueType(), fn, []llvm.Value{ptr, val, llvm.ConstInt(b.uintptrType, 5, false)}, "")
 			return llvm.Value{}
 		}
 		store := b.CreateStore(val, ptr)

compiler/calls.go

@@ -20,7 +20,7 @@ const maxFieldsPerParam = 3
 type paramInfo struct {
 	llvmType llvm.Type
 	name     string // name, possibly with suffixes for e.g. struct fields
-	flags    paramFlags
+	elemSize uint64 // size of pointer element type, or 0 if this isn't a pointer
 }
 
 // paramFlags identifies parameter attributes for flags. Most importantly, it
@@ -37,15 +37,15 @@ const (
 // createRuntimeInvoke instead.
 func (b *builder) createRuntimeCallCommon(fnName string, args []llvm.Value, name string, isInvoke bool) llvm.Value {
 	fn := b.program.ImportedPackage("runtime").Members[fnName].(*ssa.Function)
-	llvmFn := b.getFunction(fn)
+	fnType, llvmFn := b.getFunction(fn)
 	if llvmFn.IsNil() {
 		panic("trying to call non-existent function: " + fn.RelString(nil))
 	}
 	args = append(args, llvm.Undef(b.i8ptrType)) // unused context parameter
 	if isInvoke {
-		return b.createInvoke(llvmFn, args, name)
+		return b.createInvoke(fnType, llvmFn, args, name)
 	}
-	return b.createCall(llvmFn, args, name)
+	return b.createCall(fnType, llvmFn, args, name)
 }
 
 // createRuntimeCall creates a new call to runtime.<fnName> with the given
@@ -65,22 +65,22 @@ func (b *builder) createRuntimeInvoke(fnName string, args []llvm.Value, name str
 
 // createCall creates a call to the given function with the arguments possibly
 // expanded.
-func (b *builder) createCall(fn llvm.Value, args []llvm.Value, name string) llvm.Value {
+func (b *builder) createCall(fnType llvm.Type, fn llvm.Value, args []llvm.Value, name string) llvm.Value {
 	expanded := make([]llvm.Value, 0, len(args))
 	for _, arg := range args {
 		fragments := b.expandFormalParam(arg)
 		expanded = append(expanded, fragments...)
 	}
-	return b.CreateCall(fn, expanded, name)
+	return b.CreateCall(fnType, fn, expanded, name)
 }
 
 // createInvoke is like createCall but continues execution at the landing pad if
 // the call resulted in a panic.
-func (b *builder) createInvoke(fn llvm.Value, args []llvm.Value, name string) llvm.Value {
+func (b *builder) createInvoke(fnType llvm.Type, fn llvm.Value, args []llvm.Value, name string) llvm.Value {
 	if b.hasDeferFrame() {
 		b.createInvokeCheckpoint()
 	}
-	return b.createCall(fn, args, name)
+	return b.createCall(fnType, fn, args, name)
 }
 
 // Expand an argument type to a list that can be used in a function call
@@ -96,13 +96,7 @@ func (c *compilerContext) expandFormalParamType(t llvm.Type, name string, goType
 		// failed to expand this parameter: too many fields
 	}
 	// TODO: split small arrays
-	return []paramInfo{
+	return []paramInfo{c.getParamInfo(t, name, goType)}
-		{
-			llvmType: t,
-			name:     name,
-			flags:    getTypeFlags(goType),
-		},
-	}
 }
 
 // expandFormalParamOffsets returns a list of offsets from the start of an
@@ -152,7 +146,6 @@ func (b *builder) expandFormalParam(v llvm.Value) []llvm.Value {
 // Try to flatten a struct type to a list of types. Returns a 1-element slice
 // with the passed in type if this is not possible.
 func (c *compilerContext) flattenAggregateType(t llvm.Type, name string, goType types.Type) []paramInfo {
-	typeFlags := getTypeFlags(goType)
 	switch t.TypeKind() {
 	case llvm.StructTypeKind:
 		var paramInfos []paramInfo
@@ -183,40 +176,37 @@ func (c *compilerContext) flattenAggregateType(t llvm.Type, name string, goType
 				}
 			}
 			subInfos := c.flattenAggregateType(subfield, name+"."+suffix, extractSubfield(goType, i))
-			for i := range subInfos {
-				subInfos[i].flags |= typeFlags
-			}
 			paramInfos = append(paramInfos, subInfos...)
 		}
 		return paramInfos
 	default:
-		return []paramInfo{
+		return []paramInfo{c.getParamInfo(t, name, goType)}
-			{
-				llvmType: t,
-				name:     name,
-				flags:    typeFlags,
-			},
-		}
 	}
 }
 
-// getTypeFlags returns the type flags for a given type. It will not recurse
+// getParamInfo collects information about a parameter. For example, if this
-// into sub-types (such as in structs).
+// parameter is pointer-like, it will also store the element type for the
-func getTypeFlags(t types.Type) paramFlags {
+// dereferenceable_or_null attribute.
-	if t == nil {
+func (c *compilerContext) getParamInfo(t llvm.Type, name string, goType types.Type) paramInfo {
-		return 0
+	info := paramInfo{
+		llvmType: t,
+		name:     name,
 	}
-	switch t.Underlying().(type) {
+	if goType != nil {
-	case *types.Pointer:
+		switch underlying := goType.Underlying().(type) {
-		// Pointers in Go must either point to an object or be nil.
+		case *types.Pointer:
-		return paramIsDeferenceableOrNull
+			// Pointers in Go must either point to an object or be nil.
-	case *types.Chan, *types.Map:
+			info.elemSize = c.targetData.TypeAllocSize(c.getLLVMType(underlying.Elem()))
-		// Channels and maps are implemented as pointers pointing to some
+		case *types.Chan:
-		// object, and follow the same rules as *types.Pointer.
+			// Channels are implemented simply as a *runtime.channel.
-		return paramIsDeferenceableOrNull
+			info.elemSize = c.targetData.TypeAllocSize(c.getLLVMRuntimeType("channel"))
-	default:
+		case *types.Map:
-		return 0
+			// Maps are similar to channels: they are implemented as a
+			// *runtime.hashmap.
+			info.elemSize = c.targetData.TypeAllocSize(c.getLLVMRuntimeType("hashmap"))
+		}
 	}
+	return info
 }
 
 // extractSubfield extracts a field from a struct, or returns null if this is

compiler/channel.go

@@ -43,7 +43,7 @@ func (b *builder) createChanSend(instr *ssa.Send) {
 	}
 
 	// Allocate blockedlist buffer.
-	channelBlockedList := b.mod.GetTypeByName("runtime.channelBlockedList")
+	channelBlockedList := b.getLLVMRuntimeType("channelBlockedList")
 	channelBlockedListAlloca, channelBlockedListAllocaCast, channelBlockedListAllocaSize := b.createTemporaryAlloca(channelBlockedList, "chan.blockedList")
 
 	// Do the send.
@@ -75,7 +75,7 @@ func (b *builder) createChanRecv(unop *ssa.UnOp) llvm.Value {
 	}
 
 	// Allocate blockedlist buffer.
-	channelBlockedList := b.mod.GetTypeByName("runtime.channelBlockedList")
+	channelBlockedList := b.getLLVMRuntimeType("channelBlockedList")
 	channelBlockedListAlloca, channelBlockedListAllocaCast, channelBlockedListAllocaSize := b.createTemporaryAlloca(channelBlockedList, "chan.blockedList")
 
 	// Do the receive.
@@ -84,7 +84,7 @@ func (b *builder) createChanRecv(unop *ssa.UnOp) llvm.Value {
 	if isZeroSize {
 		received = llvm.ConstNull(valueType)
 	} else {
-		received = b.CreateLoad(valueAlloca, "chan.received")
+		received = b.CreateLoad(valueType, valueAlloca, "chan.received")
 		b.emitLifetimeEnd(valueAllocaCast, valueAllocaSize)
 	}
 	b.emitLifetimeEnd(channelBlockedListAllocaCast, channelBlockedListAllocaSize)
@@ -173,7 +173,7 @@ func (b *builder) createSelect(expr *ssa.Select) llvm.Value {
 		allocaType := llvm.ArrayType(b.ctx.Int8Type(), int(recvbufSize))
 		recvbufAlloca, _, _ := b.createTemporaryAlloca(allocaType, "select.recvbuf.alloca")
 		recvbufAlloca.SetAlignment(recvbufAlign)
-		recvbuf = b.CreateGEP(recvbufAlloca, []llvm.Value{
+		recvbuf = b.CreateGEP(allocaType, recvbufAlloca, []llvm.Value{
 			llvm.ConstInt(b.ctx.Int32Type(), 0, false),
 			llvm.ConstInt(b.ctx.Int32Type(), 0, false),
 		}, "select.recvbuf")
@@ -184,13 +184,13 @@ func (b *builder) createSelect(expr *ssa.Select) llvm.Value {
 	statesAlloca, statesI8, statesSize := b.createTemporaryAlloca(statesAllocaType, "select.states.alloca")
 	for i, state := range selectStates {
 		// Set each slice element to the appropriate channel.
-		gep := b.CreateGEP(statesAlloca, []llvm.Value{
+		gep := b.CreateGEP(statesAllocaType, statesAlloca, []llvm.Value{
 			llvm.ConstInt(b.ctx.Int32Type(), 0, false),
 			llvm.ConstInt(b.ctx.Int32Type(), uint64(i), false),
 		}, "")
 		b.CreateStore(state, gep)
 	}
-	statesPtr := b.CreateGEP(statesAlloca, []llvm.Value{
+	statesPtr := b.CreateGEP(statesAllocaType, statesAlloca, []llvm.Value{
 		llvm.ConstInt(b.ctx.Int32Type(), 0, false),
 		llvm.ConstInt(b.ctx.Int32Type(), 0, false),
 	}, "select.states")
@@ -204,7 +204,7 @@ func (b *builder) createSelect(expr *ssa.Select) llvm.Value {
 		chBlockAllocaType := llvm.ArrayType(b.getLLVMRuntimeType("channelBlockedList"), len(selectStates))
 		chBlockAlloca, chBlockAllocaPtr, chBlockSize := b.createTemporaryAlloca(chBlockAllocaType, "select.block.alloca")
 		chBlockLen := llvm.ConstInt(b.uintptrType, uint64(len(selectStates)), false)
-		chBlockPtr := b.CreateGEP(chBlockAlloca, []llvm.Value{
+		chBlockPtr := b.CreateGEP(chBlockAllocaType, chBlockAlloca, []llvm.Value{
 			llvm.ConstInt(b.ctx.Int32Type(), 0, false),
 			llvm.ConstInt(b.ctx.Int32Type(), 0, false),
 		}, "select.block")
@@ -264,8 +264,8 @@ 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)]
-		typ := llvm.PointerType(b.getLLVMType(expr.Type()), 0)
+		typ := b.getLLVMType(expr.Type())
-		ptr := b.CreateBitCast(recvbuf, typ, "")
+		ptr := b.CreateBitCast(recvbuf, llvm.PointerType(typ, 0), "")
-		return b.CreateLoad(ptr, "")
+		return b.CreateLoad(typ, ptr, "")
 	}
 }

compiler/compiler.go

@@ -41,6 +41,7 @@ type Config struct {
 	Triple          string
 	CPU             string
 	Features        string
+	ABI             string
 	GOOS            string
 	GOARCH          string
 	CodeModel       string
@@ -63,6 +64,7 @@ type compilerContext struct {
 	DumpSSA          bool
 	mod              llvm.Module
 	ctx              llvm.Context
+	builder          llvm.Builder // only used for constant operations
 	dibuilder        *llvm.DIBuilder
 	cu               llvm.Metadata
 	difiles          map[string]llvm.Metadata
@@ -74,6 +76,7 @@ type compilerContext struct {
 	i8ptrType        llvm.Type // for convenience
 	rawVoidFuncType  llvm.Type // for convenience
 	funcPtrAddrSpace int
+	hasTypedPointers bool // for LLVM 14 backwards compatibility
 	uintptrType      llvm.Type
 	program          *ssa.Program
 	diagnostics      []error
@@ -98,6 +101,7 @@ func newCompilerContext(moduleName string, machine llvm.TargetMachine, config *C
 	}
 
 	c.ctx = llvm.NewContext()
+	c.builder = c.ctx.NewBuilder()
 	c.mod = c.ctx.NewModule(moduleName)
 	c.mod.SetTarget(config.Triple)
 	c.mod.SetDataLayout(c.targetData.String())
@@ -120,17 +124,25 @@ func newCompilerContext(moduleName string, machine llvm.TargetMachine, config *C
 	dummyFuncType := llvm.FunctionType(c.ctx.VoidType(), nil, false)
 	dummyFunc := llvm.AddFunction(c.mod, "tinygo.dummy", dummyFuncType)
 	c.funcPtrAddrSpace = dummyFunc.Type().PointerAddressSpace()
+	c.hasTypedPointers = c.i8ptrType != llvm.PointerType(c.ctx.Int16Type(), 0) // with opaque pointers, all pointers are the same type (LLVM 15+)
 	c.rawVoidFuncType = dummyFunc.Type()
 	dummyFunc.EraseFromParentAsFunction()
 
 	return c
 }
 
+// Dispose everything related to the context, _except_ for the IR module (and
+// the associated context).
+func (c *compilerContext) dispose() {
+	c.builder.Dispose()
+}
+
 // builder contains all information relevant to build a single function.
 type builder struct {
 	*compilerContext
 	llvm.Builder
 	fn                *ssa.Function
+	llvmFnType        llvm.Type
 	llvmFn            llvm.Value
 	info              functionInfo
 	locals            map[ssa.Value]llvm.Value            // local variables
@@ -140,6 +152,7 @@ type builder struct {
 	phis              []phiNode
 	deferPtr          llvm.Value
 	deferFrame        llvm.Value
+	stackChainAlloca  llvm.Value
 	landingpad        llvm.BasicBlock
 	difunc            llvm.Metadata
 	dilocals          map[*types.Var]llvm.Metadata
@@ -155,11 +168,13 @@ type builder struct {
 }
 
 func newBuilder(c *compilerContext, irbuilder llvm.Builder, f *ssa.Function) *builder {
+	fnType, fn := c.getFunction(f)
 	return &builder{
 		compilerContext: c,
 		Builder:         irbuilder,
 		fn:              f,
-		llvmFn:          c.getFunction(f),
+		llvmFnType:      fnType,
+		llvmFn:          fn,
 		info:            c.getFunctionInfo(f),
 		locals:          make(map[ssa.Value]llvm.Value),
 		dilocals:        make(map[*types.Var]llvm.Metadata),
@@ -253,6 +268,7 @@ func Sizes(machine llvm.TargetMachine) types.Sizes {
 // CompilePackage compiles a single package to a LLVM module.
 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
@@ -309,6 +325,18 @@ func CompilePackage(moduleName string, pkg *loader.Package, ssaPkg *ssa.Package,
 		c.dibuilder.Destroy()
 	}
 
+	// Add the "target-abi" flag, which is necessary on RISC-V otherwise it will
+	// pick one that doesn't match the -mabi Clang flag.
+	if c.ABI != "" {
+		c.mod.AddNamedMetadataOperand("llvm.module.flags",
+			c.ctx.MDNode([]llvm.Metadata{
+				llvm.ConstInt(c.ctx.Int32Type(), 1, false).ConstantAsMetadata(), // Error on mismatch
+				c.ctx.MDString("target-abi"),
+				c.ctx.MDString(c.ABI),
+			}),
+		)
+	}
+
 	return c.mod, c.diagnostics
 }
 
@@ -397,14 +425,20 @@ func (c *compilerContext) makeLLVMType(goType types.Type) llvm.Type {
 		}
 		return c.getLLVMType(typ.Underlying())
 	case *types.Pointer:
-		ptrTo := c.getLLVMType(typ.Elem())
+		if c.hasTypedPointers {
-		return llvm.PointerType(ptrTo, 0)
+			ptrTo := c.getLLVMType(typ.Elem())
+			return llvm.PointerType(ptrTo, 0)
+		}
+		return c.i8ptrType // all pointers are the same
 	case *types.Signature: // function value
 		return c.getFuncType(typ)
 	case *types.Slice:
-		elemType := c.getLLVMType(typ.Elem())
+		ptrType := c.i8ptrType
+		if c.hasTypedPointers {
+			ptrType = llvm.PointerType(c.getLLVMType(typ.Elem()), 0)
+		}
 		members := []llvm.Type{
-			llvm.PointerType(elemType, 0),
+			ptrType,
 			c.uintptrType, // len
 			c.uintptrType, // cap
 		}
@@ -711,7 +745,8 @@ func (b *builder) getLocalVariable(variable *types.Var) llvm.Metadata {
 // DISubprogram metadata node.
 func (c *compilerContext) attachDebugInfo(f *ssa.Function) llvm.Metadata {
 	pos := c.program.Fset.Position(f.Syntax().Pos())
-	return c.attachDebugInfoRaw(f, c.getFunction(f), "", pos.Filename, pos.Line)
+	_, fn := c.getFunction(f)
+	return c.attachDebugInfoRaw(f, fn, "", pos.Filename, pos.Line)
 }
 
 // attachDebugInfo adds debug info to a function declaration. It returns the
@@ -784,7 +819,7 @@ func (c *compilerContext) createPackage(irbuilder llvm.Builder, pkg *ssa.Package
 		member := pkg.Members[name]
 		switch member := member.(type) {
 		case *ssa.Function:
-			if member.Synthetic == "generic function" {
+			if member.TypeParams() != nil {
 				// Do not try to build generic (non-instantiated) functions.
 				continue
 			}
@@ -849,7 +884,7 @@ func (c *compilerContext) createPackage(irbuilder llvm.Builder, pkg *ssa.Package
 			if files, ok := c.embedGlobals[member.Name()]; ok {
 				c.createEmbedGlobal(member, global, files)
 			} else if !info.extern {
-				global.SetInitializer(llvm.ConstNull(global.Type().ElementType()))
+				global.SetInitializer(llvm.ConstNull(global.GlobalValueType()))
 				global.SetVisibility(llvm.HiddenVisibility)
 				if info.section != "" {
 					global.SetSection(info.section)
@@ -914,7 +949,7 @@ func (c *compilerContext) createEmbedGlobal(member *ssa.Global, global llvm.Valu
 		bufferGlobal.SetInitializer(bufferValue)
 		bufferGlobal.SetLinkage(llvm.InternalLinkage)
 		bufferGlobal.SetAlignment(1)
-		slicePtr := llvm.ConstInBoundsGEP(bufferGlobal, []llvm.Value{
+		slicePtr := llvm.ConstInBoundsGEP(bufferValue.Type(), bufferGlobal, []llvm.Value{
 			llvm.ConstInt(c.uintptrType, 0, false),
 			llvm.ConstInt(c.uintptrType, 0, false),
 		})
@@ -968,10 +1003,10 @@ func (c *compilerContext) createEmbedGlobal(member *ssa.Global, global llvm.Valu
 		for _, file := range allFiles {
 			fileStruct := llvm.ConstNull(embedFileStructType)
 			name := c.createConst(ssa.NewConst(constant.MakeString(file.Name), types.Typ[types.String]))
-			fileStruct = llvm.ConstInsertValue(fileStruct, name, []uint32{0}) // "name" field
+			fileStruct = c.builder.CreateInsertValue(fileStruct, name, 0, "") // "name" field
 			if file.Hash != "" {
 				data := c.getEmbedFileString(file)
-				fileStruct = llvm.ConstInsertValue(fileStruct, data, []uint32{1}) // "data" field
+				fileStruct = c.builder.CreateInsertValue(fileStruct, data, 1, "") // "data" field
 			}
 			fileStructs = append(fileStructs, fileStruct)
 		}
@@ -986,7 +1021,7 @@ func (c *compilerContext) createEmbedGlobal(member *ssa.Global, global llvm.Valu
 		// Create the slice object itself.
 		// Because embed.FS refers to it as *[]embed.file instead of a plain
 		// []embed.file, we have to store this as a global.
-		slicePtr := llvm.ConstInBoundsGEP(sliceDataGlobal, []llvm.Value{
+		slicePtr := llvm.ConstInBoundsGEP(sliceDataInitializer.Type(), sliceDataGlobal, []llvm.Value{
 			llvm.ConstInt(c.uintptrType, 0, false),
 			llvm.ConstInt(c.uintptrType, 0, false),
 		})
@@ -1002,7 +1037,7 @@ func (c *compilerContext) createEmbedGlobal(member *ssa.Global, global llvm.Valu
 		// Define the embed.FS struct. It has only one field: the files (as a
 		// *[]embed.file).
 		globalInitializer := llvm.ConstNull(c.getLLVMType(member.Type().(*types.Pointer).Elem()))
-		globalInitializer = llvm.ConstInsertValue(globalInitializer, sliceGlobal, []uint32{0})
+		globalInitializer = c.builder.CreateInsertValue(globalInitializer, sliceGlobal, 0, "")
 		global.SetInitializer(globalInitializer)
 		global.SetVisibility(llvm.HiddenVisibility)
 		global.SetAlignment(c.targetData.ABITypeAlignment(globalInitializer.Type()))
@@ -1014,11 +1049,11 @@ func (c *compilerContext) createEmbedGlobal(member *ssa.Global, global llvm.Valu
 func (c *compilerContext) getEmbedFileString(file *loader.EmbedFile) llvm.Value {
 	dataGlobalName := "embed/file_" + file.Hash
 	dataGlobal := c.mod.NamedGlobal(dataGlobalName)
+	dataGlobalType := llvm.ArrayType(c.ctx.Int8Type(), int(file.Size))
 	if dataGlobal.IsNil() {
-		dataGlobalType := llvm.ArrayType(c.ctx.Int8Type(), int(file.Size))
 		dataGlobal = llvm.AddGlobal(c.mod, dataGlobalType, dataGlobalName)
 	}
-	strPtr := llvm.ConstInBoundsGEP(dataGlobal, []llvm.Value{
+	strPtr := llvm.ConstInBoundsGEP(dataGlobalType, dataGlobal, []llvm.Value{
 		llvm.ConstInt(c.uintptrType, 0, false),
 		llvm.ConstInt(c.uintptrType, 0, false),
 	})
@@ -1064,6 +1099,11 @@ func (b *builder) createFunctionStart(intrinsic bool) {
 		// otherwise the function is not exported.
 		functionAttr := b.ctx.CreateStringAttribute("wasm-export-name", b.info.linkName)
 		b.llvmFn.AddFunctionAttr(functionAttr)
+		// Unlike most targets, exported functions are actually visible in
+		// WebAssembly (even if it's not called from within the WebAssembly
+		// module). But LTO generally optimizes such functions away. Therefore,
+		// exported functions must be explicitly marked as used.
+		llvmutil.AppendToGlobal(b.mod, "llvm.used", b.llvmFn)
 	}
 
 	// Some functions have a pragma controlling the inlining level.
@@ -1192,6 +1232,13 @@ func (b *builder) createFunctionStart(intrinsic bool) {
 		// them.
 		b.deferInitFunc()
 	}
+
+	if b.NeedsStackObjects {
+		// Create a dummy alloca that will be used in runtime.trackPointer.
+		// It is necessary to pass a dummy alloca to runtime.trackPointer
+		// because runtime.trackPointer is replaced by an alloca store.
+		b.stackChainAlloca = b.CreateAlloca(b.ctx.Int8Type(), "stackalloc")
+	}
 }
 
 // createFunction builds the LLVM IR implementation for this function. The
@@ -1392,7 +1439,7 @@ func (b *builder) createInstruction(instr ssa.Instruction) {
 			b.CreateRet(b.getValue(instr.Results[0]))
 		} else {
 			// Multiple return values. Put them all in a struct.
-			retVal := llvm.ConstNull(b.llvmFn.Type().ElementType().ReturnType())
+			retVal := llvm.ConstNull(b.llvmFn.GlobalValueType().ReturnType())
 			for i, result := range instr.Results {
 				val := b.getValue(result)
 				retVal = b.CreateInsertValue(retVal, val, i, "")
@@ -1431,7 +1478,7 @@ func (b *builder) createBuiltin(argTypes []types.Type, argValues []llvm.Value, c
 		elemsBuf := b.CreateExtractValue(elems, 0, "append.elemsBuf")
 		elemsPtr := b.CreateBitCast(elemsBuf, b.i8ptrType, "append.srcPtr")
 		elemsLen := b.CreateExtractValue(elems, 1, "append.elemsLen")
-		elemType := srcBuf.Type().ElementType()
+		elemType := b.getLLVMType(argTypes[0].Underlying().(*types.Slice).Elem())
 		elemSize := llvm.ConstInt(b.uintptrType, b.targetData.TypeAllocSize(elemType), false)
 		result := b.createRuntimeCall("sliceAppend", []llvm.Value{srcPtr, elemsPtr, srcLen, srcCap, elemsLen, elemSize}, "append.new")
 		newPtr := b.CreateExtractValue(result, 0, "append.newPtr")
@@ -1484,7 +1531,7 @@ func (b *builder) createBuiltin(argTypes []types.Type, argValues []llvm.Value, c
 		srcLen := b.CreateExtractValue(src, 1, "copy.srcLen")
 		dstBuf := b.CreateExtractValue(dst, 0, "copy.dstArray")
 		srcBuf := b.CreateExtractValue(src, 0, "copy.srcArray")
-		elemType := dstBuf.Type().ElementType()
+		elemType := b.getLLVMType(argTypes[0].Underlying().(*types.Slice).Elem())
 		dstBuf = b.CreateBitCast(dstBuf, b.i8ptrType, "copy.dstPtr")
 		srcBuf = b.CreateBitCast(srcBuf, b.i8ptrType, "copy.srcPtr")
 		elemSize := llvm.ConstInt(b.uintptrType, b.targetData.TypeAllocSize(elemType), false)
@@ -1597,7 +1644,7 @@ func (b *builder) createBuiltin(argTypes []types.Type, argValues []llvm.Value, c
 		// Note: the pointer is always of type *i8.
 		ptr := argValues[0]
 		len := argValues[1]
-		return b.CreateGEP(ptr, []llvm.Value{len}, ""), nil
+		return b.CreateGEP(b.ctx.Int8Type(), ptr, []llvm.Value{len}, ""), nil
 	case "Alignof": // unsafe.Alignof
 		align := b.targetData.ABITypeAlignment(argValues[0].Type())
 		return llvm.ConstInt(b.uintptrType, uint64(align), false), nil
@@ -1612,19 +1659,20 @@ func (b *builder) createBuiltin(argTypes []types.Type, argValues []llvm.Value, c
 	case "Sizeof": // unsafe.Sizeof
 		size := b.targetData.TypeAllocSize(argValues[0].Type())
 		return llvm.ConstInt(b.uintptrType, size, false), nil
-	case "Slice": // unsafe.Slice
+	case "Slice", "String": // unsafe.Slice, unsafe.String
-		// This creates a slice from a pointer and a length.
+		// This creates a slice or string from a pointer and a length.
 		// Note that the exception mentioned in the documentation (if the
 		// pointer and length are nil, the slice is also nil) is trivially
 		// already the case.
 		ptr := argValues[0]
 		len := argValues[1]
-		slice := llvm.Undef(b.ctx.StructType([]llvm.Type{
+		var elementType llvm.Type
-			ptr.Type(),
+		if callName == "Slice" {
-			b.uintptrType,
+			elementType = b.getLLVMType(argTypes[0].Underlying().(*types.Pointer).Elem())
-			b.uintptrType,
+		} else {
-		}, false))
+			elementType = b.ctx.Int8Type()
-		b.createUnsafeSliceCheck(ptr, len, argTypes[1].Underlying().(*types.Basic))
+		}
+		b.createUnsafeSliceStringCheck("unsafe."+callName, ptr, len, elementType, argTypes[1].Underlying().(*types.Basic))
 		if len.Type().IntTypeWidth() < b.uintptrType.IntTypeWidth() {
 			// Too small, zero-extend len.
 			len = b.CreateZExt(len, b.uintptrType, "")
@@ -1632,10 +1680,24 @@ func (b *builder) createBuiltin(argTypes []types.Type, argValues []llvm.Value, c
 			// Too big, truncate len.
 			len = b.CreateTrunc(len, b.uintptrType, "")
 		}
-		slice = b.CreateInsertValue(slice, ptr, 0, "")
+		if callName == "Slice" {
-		slice = b.CreateInsertValue(slice, len, 1, "")
+			slice := llvm.Undef(b.ctx.StructType([]llvm.Type{
-		slice = b.CreateInsertValue(slice, len, 2, "")
+				ptr.Type(),
-		return slice, nil
+				b.uintptrType,
+				b.uintptrType,
+			}, false))
+			slice = b.CreateInsertValue(slice, ptr, 0, "")
+			slice = b.CreateInsertValue(slice, len, 1, "")
+			slice = b.CreateInsertValue(slice, len, 2, "")
+			return slice, nil
+		} else {
+			str := llvm.Undef(b.getLLVMRuntimeType("_string"))
+			str = b.CreateInsertValue(str, argValues[0], 0, "")
+			str = b.CreateInsertValue(str, len, 1, "")
+			return str, nil
+		}
+	case "SliceData", "StringData": // unsafe.SliceData, unsafe.StringData
+		return b.CreateExtractValue(argValues[0], 0, "slice.data"), nil
 	default:
 		return llvm.Value{}, b.makeError(pos, "todo: builtin: "+callName)
 	}
@@ -1654,6 +1716,7 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 
 	// 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
@@ -1684,7 +1747,7 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 			return b.createInterruptGlobal(instr)
 		}
 
-		callee = b.getFunction(fn)
+		calleeType, callee = b.getFunction(fn)
 		info := b.getFunctionInfo(fn)
 		if callee.IsNil() {
 			return llvm.Value{}, b.makeError(instr.Pos(), "undefined function: "+info.linkName)
@@ -1698,8 +1761,8 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 				// Eventually we might be able to eliminate this special case
 				// entirely. For details, see:
 				// https://discourse.llvm.org/t/rfc-enabling-wstrict-prototypes-by-default-in-c/60521
-				fnType := llvm.FunctionType(callee.Type().ElementType().ReturnType(), nil, false)
+				calleeType = llvm.FunctionType(callee.GlobalValueType().ReturnType(), nil, false)
-				callee = llvm.ConstBitCast(callee, llvm.PointerType(fnType, b.funcPtrAddrSpace))
+				callee = llvm.ConstBitCast(callee, llvm.PointerType(calleeType, b.funcPtrAddrSpace))
 			}
 		case *ssa.MakeClosure:
 			// A call on a func value, but the callee is trivial to find. For
@@ -1726,13 +1789,14 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 		params = append([]llvm.Value{value}, params...)
 		params = append(params, typecode)
 		callee = b.getInvokeFunction(instr)
+		calleeType = callee.GlobalValueType()
 		context = llvm.Undef(b.i8ptrType)
 	} else {
 		// Function pointer.
 		value := b.getValue(instr.Value)
 		// This is a func value, which cannot be called directly. We have to
 		// extract the function pointer and context first from the func value.
-		callee, context = b.decodeFuncValue(value, instr.Value.Type().Underlying().(*types.Signature))
+		calleeType, callee, context = b.decodeFuncValue(value, instr.Value.Type().Underlying().(*types.Signature))
 		b.createNilCheck(instr.Value, callee, "fpcall")
 	}
 
@@ -1742,7 +1806,7 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 		params = append(params, context)
 	}
 
-	return b.createInvoke(callee, params, ""), nil
+	return b.createInvoke(calleeType, callee, params, ""), nil
 }
 
 // getValue returns the LLVM value of a constant, function value, global, or
@@ -1756,7 +1820,8 @@ func (b *builder) getValue(expr ssa.Value) llvm.Value {
 			b.addError(expr.Pos(), "cannot use an exported function as value: "+expr.String())
 			return llvm.Undef(b.getLLVMType(expr.Type()))
 		}
-		return b.createFuncValue(b.getFunction(expr), llvm.Undef(b.i8ptrType), expr.Signature)
+		_, fn := b.getFunction(expr)
+		return b.createFuncValue(fn, llvm.Undef(b.i8ptrType), expr.Signature)
 	case *ssa.Global:
 		value := b.getGlobal(expr)
 		if value.IsNil() {
@@ -1904,46 +1969,77 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 			llvm.ConstInt(b.ctx.Int32Type(), 0, false),
 			llvm.ConstInt(b.ctx.Int32Type(), uint64(expr.Field), false),
 		}
-		return b.CreateInBoundsGEP(val, indices, ""), nil
+		elementType := b.getLLVMType(expr.X.Type().Underlying().(*types.Pointer).Elem())
+		return b.CreateInBoundsGEP(elementType, val, indices, ""), nil
 	case *ssa.Function:
 		panic("function is not an expression")
 	case *ssa.Global:
 		panic("global is not an expression")
 	case *ssa.Index:
-		array := b.getValue(expr.X)
+		collection := b.getValue(expr.X)
 		index := b.getValue(expr.Index)
 
-		// Extend index to at least uintptr size, because getelementptr assumes
+		switch xType := expr.X.Type().Underlying().(type) {
-		// index is a signed integer.
+		case *types.Basic: // extract byte from string
-		index = b.extendInteger(index, expr.Index.Type(), b.uintptrType)
+			// Value type must be a string, which is a basic type.
+			if xType.Info()&types.IsString == 0 {
+				panic("lookup on non-string?")
+			}
 
-		// Check bounds.
+			// Sometimes, the index can be e.g. an uint8 or int8, and we have to
-		arrayLen := expr.X.Type().Underlying().(*types.Array).Len()
+			// correctly extend that type for two reasons:
-		arrayLenLLVM := llvm.ConstInt(b.uintptrType, uint64(arrayLen), false)
+			//  1. The lookup bounds check expects an index of at least uintptr
-		b.createLookupBoundsCheck(arrayLenLLVM, index)
+			//     size.
+			//  2. getelementptr has signed operands, and therefore s[uint8(x)]
+			//     can be lowered as s[int8(x)]. That would be a bug.
+			index = b.extendInteger(index, expr.Index.Type(), b.uintptrType)
 
-		// Can't load directly from array (as index is non-constant), so have to
+			// Bounds check.
-		// do it using an alloca+gep+load.
+			length := b.CreateExtractValue(collection, 1, "len")
-		alloca, allocaPtr, allocaSize := b.createTemporaryAlloca(array.Type(), "index.alloca")
+			b.createLookupBoundsCheck(length, index)
-		b.CreateStore(array, alloca)
+
-		zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
+			// Lookup byte
-		ptr := b.CreateInBoundsGEP(alloca, []llvm.Value{zero, index}, "index.gep")
+			buf := b.CreateExtractValue(collection, 0, "")
-		result := b.CreateLoad(ptr, "index.load")
+			bufElemType := b.ctx.Int8Type()
-		b.emitLifetimeEnd(allocaPtr, allocaSize)
+			bufPtr := b.CreateInBoundsGEP(bufElemType, buf, []llvm.Value{index}, "")
-		return result, nil
+			return b.CreateLoad(bufElemType, bufPtr, ""), nil
+		case *types.Array: // extract element from array
+			// Extend index to at least uintptr size, because getelementptr
+			// assumes index is a signed integer.
+			index = b.extendInteger(index, expr.Index.Type(), b.uintptrType)
+
+			// Check bounds.
+			arrayLen := llvm.ConstInt(b.uintptrType, uint64(xType.Len()), false)
+			b.createLookupBoundsCheck(arrayLen, index)
+
+			// Can't load directly from array (as index is non-constant), so
+			// have to do it using an alloca+gep+load.
+			arrayType := collection.Type()
+			alloca, allocaPtr, allocaSize := b.createTemporaryAlloca(arrayType, "index.alloca")
+			b.CreateStore(collection, alloca)
+			zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
+			ptr := b.CreateInBoundsGEP(arrayType, alloca, []llvm.Value{zero, index}, "index.gep")
+			result := b.CreateLoad(arrayType.ElementType(), ptr, "index.load")
+			b.emitLifetimeEnd(allocaPtr, allocaSize)
+			return result, nil
+		default:
+			panic("unknown *ssa.Index type")
+		}
 	case *ssa.IndexAddr:
 		val := b.getValue(expr.X)
 		index := b.getValue(expr.Index)
 
 		// Get buffer pointer and length
 		var bufptr, buflen llvm.Value
+		var bufType llvm.Type
 		switch ptrTyp := expr.X.Type().Underlying().(type) {
 		case *types.Pointer:
-			typ := expr.X.Type().Underlying().(*types.Pointer).Elem().Underlying()
+			typ := ptrTyp.Elem().Underlying()
 			switch typ := typ.(type) {
 			case *types.Array:
 				bufptr = val
 				buflen = llvm.ConstInt(b.uintptrType, uint64(typ.Len()), false)
+				bufType = b.getLLVMType(typ)
 				// Check for nil pointer before calculating the address, from
 				// the spec:
 				// > For an operand x of type T, the address operation &x
@@ -1957,6 +2053,7 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 		case *types.Slice:
 			bufptr = b.CreateExtractValue(val, 0, "indexaddr.ptr")
 			buflen = b.CreateExtractValue(val, 1, "indexaddr.len")
+			bufType = b.getLLVMType(ptrTyp.Elem())
 		default:
 			return llvm.Value{}, b.makeError(expr.Pos(), "todo: indexaddr: "+ptrTyp.String())
 		}
@@ -1974,47 +2071,20 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 				llvm.ConstInt(b.ctx.Int32Type(), 0, false),
 				index,
 			}
-			return b.CreateInBoundsGEP(bufptr, indices, ""), nil
+			return b.CreateInBoundsGEP(bufType, bufptr, indices, ""), nil
 		case *types.Slice:
-			return b.CreateInBoundsGEP(bufptr, []llvm.Value{index}, ""), nil
+			return b.CreateInBoundsGEP(bufType, bufptr, []llvm.Value{index}, ""), nil
 		default:
 			panic("unreachable")
 		}
-	case *ssa.Lookup:
+	case *ssa.Lookup: // map lookup
 		value := b.getValue(expr.X)
 		index := b.getValue(expr.Index)
-		switch xType := expr.X.Type().Underlying().(type) {
+		valueType := expr.Type()
-		case *types.Basic:
+		if expr.CommaOk {
-			// Value type must be a string, which is a basic type.
+			valueType = valueType.(*types.Tuple).At(0).Type()
-			if xType.Info()&types.IsString == 0 {
-				panic("lookup on non-string?")
-			}
-
-			// Sometimes, the index can be e.g. an uint8 or int8, and we have to
-			// correctly extend that type for two reasons:
-			//  1. The lookup bounds check expects an index of at least uintptr
-			//     size.
-			//  2. getelementptr has signed operands, and therefore s[uint8(x)]
-			//     can be lowered as s[int8(x)]. That would be a bug.
-			index = b.extendInteger(index, expr.Index.Type(), b.uintptrType)
-
-			// Bounds check.
-			length := b.CreateExtractValue(value, 1, "len")
-			b.createLookupBoundsCheck(length, index)
-
-			// Lookup byte
-			buf := b.CreateExtractValue(value, 0, "")
-			bufPtr := b.CreateInBoundsGEP(buf, []llvm.Value{index}, "")
-			return b.CreateLoad(bufPtr, ""), nil
-		case *types.Map:
-			valueType := expr.Type()
-			if expr.CommaOk {
-				valueType = valueType.(*types.Tuple).At(0).Type()
-			}
-			return b.createMapLookup(xType.Key(), valueType, value, index, expr.CommaOk, expr.Pos())
-		default:
-			panic("unknown lookup type: " + expr.String())
 		}
+		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:
@@ -2138,7 +2208,8 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 		switch typ := expr.X.Type().Underlying().(type) {
 		case *types.Pointer: // pointer to array
 			// slice an array
-			length := typ.Elem().Underlying().(*types.Array).Len()
+			arrayType := typ.Elem().Underlying().(*types.Array)
+			length := arrayType.Len()
 			llvmLen := llvm.ConstInt(b.uintptrType, uint64(length), false)
 			if high.IsNil() {
 				high = llvmLen
@@ -2167,7 +2238,7 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 			}
 
 			sliceLen := b.CreateSub(high, low, "slice.len")
-			slicePtr := b.CreateInBoundsGEP(value, indices, "slice.ptr")
+			slicePtr := b.CreateInBoundsGEP(b.getLLVMType(arrayType), value, indices, "slice.ptr")
 			sliceCap := b.CreateSub(max, low, "slice.cap")
 
 			slice := b.ctx.ConstStruct([]llvm.Value{
@@ -2206,7 +2277,8 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 				max = b.CreateTrunc(max, b.uintptrType, "")
 			}
 
-			newPtr := b.CreateInBoundsGEP(oldPtr, []llvm.Value{low}, "")
+			ptrElemType := b.getLLVMType(typ.Elem())
+			newPtr := b.CreateInBoundsGEP(ptrElemType, oldPtr, []llvm.Value{low}, "")
 			newLen := b.CreateSub(high, low, "")
 			newCap := b.CreateSub(max, low, "")
 			slice := b.ctx.ConstStruct([]llvm.Value{
@@ -2246,7 +2318,7 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 				high = b.CreateTrunc(high, b.uintptrType, "")
 			}
 
-			newPtr := b.CreateInBoundsGEP(oldPtr, []llvm.Value{low}, "")
+			newPtr := b.CreateInBoundsGEP(b.ctx.Int8Type(), oldPtr, []llvm.Value{low}, "")
 			newLen := b.CreateSub(high, low, "")
 			str := llvm.Undef(b.getLLVMRuntimeType("_string"))
 			str = b.CreateInsertValue(str, newPtr, 0, "")
@@ -2709,14 +2781,15 @@ func (c *compilerContext) createConst(expr *ssa.Const) llvm.Value {
 			var strPtr llvm.Value
 			if str != "" {
 				objname := c.pkg.Path() + "$string"
-				global := llvm.AddGlobal(c.mod, llvm.ArrayType(c.ctx.Int8Type(), len(str)), objname)
+				globalType := llvm.ArrayType(c.ctx.Int8Type(), len(str))
+				global := llvm.AddGlobal(c.mod, globalType, objname)
 				global.SetInitializer(c.ctx.ConstString(str, false))
 				global.SetLinkage(llvm.InternalLinkage)
 				global.SetGlobalConstant(true)
 				global.SetUnnamedAddr(true)
 				global.SetAlignment(1)
 				zero := llvm.ConstInt(c.ctx.Int32Type(), 0, false)
-				strPtr = llvm.ConstInBoundsGEP(global, []llvm.Value{zero, zero})
+				strPtr = llvm.ConstInBoundsGEP(globalType, global, []llvm.Value{zero, zero})
 			} else {
 				strPtr = llvm.ConstNull(c.i8ptrType)
 			}
@@ -2741,15 +2814,15 @@ func (c *compilerContext) createConst(expr *ssa.Const) llvm.Value {
 			r := c.createConst(ssa.NewConst(constant.Real(expr.Value), types.Typ[types.Float32]))
 			i := c.createConst(ssa.NewConst(constant.Imag(expr.Value), types.Typ[types.Float32]))
 			cplx := llvm.Undef(c.ctx.StructType([]llvm.Type{c.ctx.FloatType(), c.ctx.FloatType()}, false))
-			cplx = llvm.ConstInsertValue(cplx, r, []uint32{0})
+			cplx = c.builder.CreateInsertValue(cplx, r, 0, "")
-			cplx = llvm.ConstInsertValue(cplx, i, []uint32{1})
+			cplx = c.builder.CreateInsertValue(cplx, i, 1, "")
 			return cplx
 		} else if typ.Kind() == types.Complex128 {
 			r := c.createConst(ssa.NewConst(constant.Real(expr.Value), types.Typ[types.Float64]))
 			i := c.createConst(ssa.NewConst(constant.Imag(expr.Value), types.Typ[types.Float64]))
 			cplx := llvm.Undef(c.ctx.StructType([]llvm.Type{c.ctx.DoubleType(), c.ctx.DoubleType()}, false))
-			cplx = llvm.ConstInsertValue(cplx, r, []uint32{0})
+			cplx = c.builder.CreateInsertValue(cplx, r, 0, "")
-			cplx = llvm.ConstInsertValue(cplx, i, []uint32{1})
+			cplx = c.builder.CreateInsertValue(cplx, i, 1, "")
 			return cplx
 		} else {
 			panic("unknown constant of basic type: " + expr.String())
@@ -2836,7 +2909,7 @@ func (b *builder) createConvert(typeFrom, typeTo types.Type, value llvm.Value, p
 					// create a GEP that is not in bounds. However, we're
 					// talking about unsafe code here so the programmer has to
 					// be careful anyway.
-					return b.CreateInBoundsGEP(origptr, []llvm.Value{index}, ""), nil
+					return b.CreateInBoundsGEP(b.ctx.Int8Type(), origptr, []llvm.Value{index}, ""), nil
 				}
 			}
 		}
@@ -3069,10 +3142,10 @@ func (b *builder) createUnOp(unop *ssa.UnOp) (llvm.Value, error) {
 			return llvm.Value{}, b.makeError(unop.Pos(), "todo: unknown type for negate: "+unop.X.Type().Underlying().String())
 		}
 	case token.MUL: // *x, dereference pointer
-		unop.X.Type().Underlying().(*types.Pointer).Elem()
+		valueType := b.getLLVMType(unop.X.Type().Underlying().(*types.Pointer).Elem())
-		if b.targetData.TypeAllocSize(x.Type().ElementType()) == 0 {
+		if b.targetData.TypeAllocSize(valueType) == 0 {
 			// zero-length data
-			return llvm.ConstNull(x.Type().ElementType()), nil
+			return llvm.ConstNull(valueType), nil
 		} else if strings.HasSuffix(unop.X.String(), "$funcaddr") {
 			// CGo function pointer. The cgo part has rewritten CGo function
 			// pointers as stub global variables of the form:
@@ -3080,14 +3153,14 @@ func (b *builder) createUnOp(unop *ssa.UnOp) (llvm.Value, error) {
 			// Instead of a load from the global, create a bitcast of the
 			// function pointer itself.
 			name := strings.TrimSuffix(unop.X.(*ssa.Global).Name(), "$funcaddr")
-			fn := b.getFunction(b.fn.Pkg.Members[name].(*ssa.Function))
+			_, fn := b.getFunction(b.fn.Pkg.Members[name].(*ssa.Function))
 			if fn.IsNil() {
 				return llvm.Value{}, b.makeError(unop.Pos(), "cgo function not found: "+name)
 			}
 			return b.CreateBitCast(fn, b.i8ptrType, ""), nil
 		} else {
 			b.createNilCheck(unop.X, x, "deref")
-			load := b.CreateLoad(x, "")
+			load := b.CreateLoad(valueType, x, "")
 			return load, nil
 		}
 	case token.XOR: // ^x, toggle all bits in integer

compiler/compiler_test.go

@@ -9,6 +9,7 @@ import (
 	"testing"
 
 	"github.com/tinygo-org/tinygo/compileopts"
+	"github.com/tinygo-org/tinygo/goenv"
 	"github.com/tinygo-org/tinygo/loader"
 	"tinygo.org/x/go-llvm"
 )
@@ -27,6 +28,12 @@ type testCase struct {
 func TestCompiler(t *testing.T) {
 	t.Parallel()
 
+	// Determine Go minor version (e.g. 16 in go1.16.3).
+	_, goMinor, err := goenv.GetGorootVersion(goenv.Get("GOROOT"))
+	if err != nil {
+		t.Fatal("could not read Go version:", err)
+	}
+
 	// Determine which tests to run, depending on the Go and LLVM versions.
 	tests := []testCase{
 		{"basic.go", "", ""},
@@ -43,6 +50,9 @@ func TestCompiler(t *testing.T) {
 		{"channel.go", "", ""},
 		{"gc.go", "", ""},
 	}
+	if goMinor >= 20 {
+		tests = append(tests, testCase{"go1.20.go", "", ""})
+	}
 
 	for _, tc := range tests {
 		name := tc.file
@@ -73,6 +83,7 @@ func TestCompiler(t *testing.T) {
 			compilerConfig := &Config{
 				Triple:             config.Triple(),
 				Features:           config.Features(),
+				ABI:                config.ABI(),
 				GOOS:               config.GOOS(),
 				GOARCH:             config.GOARCH(),
 				CodeModel:          config.CodeModel(),

compiler/defer.go

@@ -162,9 +162,9 @@ mov x0, #0
 1:
 `
 		constraints = "={x0},{x1},~{x1},~{x2},~{x3},~{x4},~{x5},~{x6},~{x7},~{x8},~{x9},~{x10},~{x11},~{x12},~{x13},~{x14},~{x15},~{x16},~{x17},~{x19},~{x20},~{x21},~{x22},~{x23},~{x24},~{x25},~{x26},~{x27},~{x28},~{lr},~{q0},~{q1},~{q2},~{q3},~{q4},~{q5},~{q6},~{q7},~{q8},~{q9},~{q10},~{q11},~{q12},~{q13},~{q14},~{q15},~{q16},~{q17},~{q18},~{q19},~{q20},~{q21},~{q22},~{q23},~{q24},~{q25},~{q26},~{q27},~{q28},~{q29},~{q30},~{nzcv},~{ffr},~{vg},~{memory}"
-		if b.GOOS != "darwin" {
+		if b.GOOS != "darwin" && b.GOOS != "windows" {
 			// These registers cause the following warning when compiling for
-			// MacOS:
+			// MacOS and Windows:
 			//     warning: inline asm clobber list contains reserved registers:
 			//     X18, FP
 			//     Reserved registers on the clobber list may not be preserved
@@ -201,7 +201,7 @@ li a0, 0
 	}
 	asmType := llvm.FunctionType(resultType, []llvm.Type{b.deferFrame.Type()}, false)
 	asm := llvm.InlineAsm(asmType, asmString, constraints, false, false, 0, false)
-	result := b.CreateCall(asm, []llvm.Value{b.deferFrame}, "setjmp")
+	result := 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")
 	continueBB := b.insertBasicBlock("")
@@ -249,7 +249,8 @@ func isInLoop(start *ssa.BasicBlock) bool {
 func (b *builder) createDefer(instr *ssa.Defer) {
 	// The pointer to the previous defer struct, which we will replace to
 	// make a linked list.
-	next := b.CreateLoad(b.deferPtr, "defer.next")
+	deferType := llvm.PointerType(b.getLLVMRuntimeType("_defer"), 0)
+	next := b.CreateLoad(deferType, b.deferPtr, "defer.next")
 
 	var values []llvm.Value
 	valueTypes := []llvm.Type{b.uintptrType, next.Type()}
@@ -406,6 +407,9 @@ func (b *builder) createDefer(instr *ssa.Defer) {
 
 // createRunDefers emits code to run all deferred functions.
 func (b *builder) createRunDefers() {
+	deferType := b.getLLVMRuntimeType("_defer")
+	deferPtrType := llvm.PointerType(deferType, 0)
+
 	// Add a loop like the following:
 	//     for stack != nil {
 	//         _stack := stack
@@ -431,7 +435,7 @@ func (b *builder) createRunDefers() {
 	// Create loop head:
 	//     for stack != nil {
 	b.SetInsertPointAtEnd(loophead)
-	deferData := b.CreateLoad(b.deferPtr, "")
+	deferData := b.CreateLoad(deferPtrType, b.deferPtr, "")
 	stackIsNil := b.CreateICmp(llvm.IntEQ, deferData, llvm.ConstPointerNull(deferData.Type()), "stackIsNil")
 	b.CreateCondBr(stackIsNil, end, loop)
 
@@ -440,17 +444,17 @@ func (b *builder) createRunDefers() {
 	//     stack = stack.next
 	//     switch stack.callback {
 	b.SetInsertPointAtEnd(loop)
-	nextStackGEP := b.CreateInBoundsGEP(deferData, []llvm.Value{
+	nextStackGEP := b.CreateInBoundsGEP(deferType, deferData, []llvm.Value{
 		llvm.ConstInt(b.ctx.Int32Type(), 0, false),
 		llvm.ConstInt(b.ctx.Int32Type(), 1, false), // .next field
 	}, "stack.next.gep")
-	nextStack := b.CreateLoad(nextStackGEP, "stack.next")
+	nextStack := b.CreateLoad(deferPtrType, nextStackGEP, "stack.next")
 	b.CreateStore(nextStack, b.deferPtr)
-	gep := b.CreateInBoundsGEP(deferData, []llvm.Value{
+	gep := b.CreateInBoundsGEP(deferType, deferData, []llvm.Value{
 		llvm.ConstInt(b.ctx.Int32Type(), 0, false),
 		llvm.ConstInt(b.ctx.Int32Type(), 0, false), // .callback field
 	}, "callback.gep")
-	callback := b.CreateLoad(gep, "callback")
+	callback := b.CreateLoad(b.uintptrType, gep, "callback")
 	sw := b.CreateSwitch(callback, unreachable, len(b.allDeferFuncs))
 
 	for i, callback := range b.allDeferFuncs {
@@ -486,12 +490,13 @@ func (b *builder) createRunDefers() {
 			forwardParams := []llvm.Value{}
 			zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
 			for i := 2; i < len(valueTypes); i++ {
-				gep := b.CreateInBoundsGEP(deferredCallPtr, []llvm.Value{zero, llvm.ConstInt(b.ctx.Int32Type(), uint64(i), false)}, "gep")
+				gep := b.CreateInBoundsGEP(deferredCallType, deferredCallPtr, []llvm.Value{zero, llvm.ConstInt(b.ctx.Int32Type(), uint64(i), false)}, "gep")
-				forwardParam := b.CreateLoad(gep, "param")
+				forwardParam := b.CreateLoad(valueTypes[i], gep, "param")
 				forwardParams = append(forwardParams, forwardParam)
 			}
 
 			var fnPtr llvm.Value
+			var fnType llvm.Type
 
 			if !callback.IsInvoke() {
 				// Isolate the func value.
@@ -499,8 +504,8 @@ func (b *builder) createRunDefers() {
 				forwardParams = forwardParams[1:]
 
 				//Get function pointer and context
-				fp, context := b.decodeFuncValue(funcValue, callback.Signature())
+				var context llvm.Value
-				fnPtr = fp
+				fnType, fnPtr, context = b.decodeFuncValue(funcValue, callback.Signature())
 
 				//Pass context
 				forwardParams = append(forwardParams, context)
@@ -509,6 +514,7 @@ func (b *builder) createRunDefers() {
 				// parameters.
 				forwardParams = append(forwardParams[1:], forwardParams[0])
 				fnPtr = b.getInvokeFunction(callback)
+				fnType = fnPtr.GlobalValueType()
 
 				// Add the context parameter. An interface call cannot also be a
 				// closure but we have to supply the parameter anyway for platforms
@@ -516,7 +522,7 @@ func (b *builder) createRunDefers() {
 				forwardParams = append(forwardParams, llvm.Undef(b.i8ptrType))
 			}
 
-			b.createCall(fnPtr, forwardParams, "")
+			b.createCall(fnType, fnPtr, forwardParams, "")
 
 		case *ssa.Function:
 			// Direct call.
@@ -533,8 +539,8 @@ func (b *builder) createRunDefers() {
 			forwardParams := []llvm.Value{}
 			zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
 			for i := range getParams(callback.Signature) {
-				gep := b.CreateInBoundsGEP(deferredCallPtr, []llvm.Value{zero, llvm.ConstInt(b.ctx.Int32Type(), uint64(i+2), false)}, "gep")
+				gep := b.CreateInBoundsGEP(deferredCallType, deferredCallPtr, []llvm.Value{zero, llvm.ConstInt(b.ctx.Int32Type(), uint64(i+2), false)}, "gep")
-				forwardParam := b.CreateLoad(gep, "param")
+				forwardParam := b.CreateLoad(valueTypes[i+2], gep, "param")
 				forwardParams = append(forwardParams, forwardParam)
 			}
 
@@ -547,7 +553,8 @@ func (b *builder) createRunDefers() {
 			}
 
 			// Call real function.
-			b.createInvoke(b.getFunction(callback), forwardParams, "")
+			fnType, fn := b.getFunction(callback)
+			b.createInvoke(fnType, fn, forwardParams, "")
 
 		case *ssa.MakeClosure:
 			// Get the real defer struct type and cast to it.
@@ -565,13 +572,14 @@ func (b *builder) createRunDefers() {
 			forwardParams := []llvm.Value{}
 			zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
 			for i := 2; i < len(valueTypes); i++ {
-				gep := b.CreateInBoundsGEP(deferredCallPtr, []llvm.Value{zero, llvm.ConstInt(b.ctx.Int32Type(), uint64(i), false)}, "")
+				gep := b.CreateInBoundsGEP(deferredCallType, deferredCallPtr, []llvm.Value{zero, llvm.ConstInt(b.ctx.Int32Type(), uint64(i), false)}, "")
-				forwardParam := b.CreateLoad(gep, "param")
+				forwardParam := b.CreateLoad(valueTypes[i], gep, "param")
 				forwardParams = append(forwardParams, forwardParam)
 			}
 
 			// Call deferred function.
-			b.createCall(b.getFunction(fn), forwardParams, "")
+			fnType, llvmFn := b.getFunction(fn)
+			b.createCall(fnType, llvmFn, forwardParams, "")
 		case *ssa.Builtin:
 			db := b.deferBuiltinFuncs[callback]
 
@@ -591,8 +599,8 @@ func (b *builder) createRunDefers() {
 			var argValues []llvm.Value
 			zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
 			for i := 0; i < params.Len(); i++ {
-				gep := b.CreateInBoundsGEP(deferredCallPtr, []llvm.Value{zero, llvm.ConstInt(b.ctx.Int32Type(), uint64(i+2), false)}, "gep")
+				gep := b.CreateInBoundsGEP(deferredCallType, deferredCallPtr, []llvm.Value{zero, llvm.ConstInt(b.ctx.Int32Type(), uint64(i+2), false)}, "gep")
-				forwardParam := b.CreateLoad(gep, "param")
+				forwardParam := b.CreateLoad(valueTypes[i+2], gep, "param")
 				argValues = append(argValues, forwardParam)
 			}
 

compiler/func.go

@@ -55,15 +55,17 @@ func (b *builder) extractFuncContext(funcValue llvm.Value) llvm.Value {
 
 // decodeFuncValue extracts the context and the function pointer from this func
 // value. This may be an expensive operation.
-func (b *builder) decodeFuncValue(funcValue llvm.Value, sig *types.Signature) (funcPtr, context llvm.Value) {
+func (b *builder) decodeFuncValue(funcValue llvm.Value, sig *types.Signature) (funcType llvm.Type, funcPtr, context llvm.Value) {
 	context = b.CreateExtractValue(funcValue, 0, "")
-	bitcast := b.CreateExtractValue(funcValue, 1, "")
+	funcPtr = b.CreateExtractValue(funcValue, 1, "")
-	if !bitcast.IsAConstantExpr().IsNil() && bitcast.Opcode() == llvm.BitCast {
+	if !funcPtr.IsAConstantExpr().IsNil() && funcPtr.Opcode() == llvm.BitCast {
-		funcPtr = bitcast.Operand(0)
+		funcPtr = funcPtr.Operand(0) // needed for LLVM 14 (no opaque pointers)
-		return
+	}
+	if sig != nil {
+		funcType = b.getRawFuncType(sig)
+		llvmSig := llvm.PointerType(funcType, b.funcPtrAddrSpace)
+		funcPtr = b.CreateBitCast(funcPtr, llvmSig, "")
 	}
-	llvmSig := b.getRawFuncType(sig)
-	funcPtr = b.CreateBitCast(bitcast, llvmSig, "")
 	return
 }
 
@@ -72,7 +74,7 @@ func (c *compilerContext) getFuncType(typ *types.Signature) llvm.Type {
 	return c.ctx.StructType([]llvm.Type{c.i8ptrType, c.rawVoidFuncType}, false)
 }
 
-// getRawFuncType returns a LLVM function pointer type for a given signature.
+// getRawFuncType returns a LLVM function type for a given signature.
 func (c *compilerContext) getRawFuncType(typ *types.Signature) llvm.Type {
 	// Get the return type.
 	var returnType llvm.Type
@@ -117,7 +119,7 @@ func (c *compilerContext) getRawFuncType(typ *types.Signature) llvm.Type {
 	paramTypes = append(paramTypes, c.i8ptrType) // context
 
 	// Make a func type out of the signature.
-	return llvm.PointerType(llvm.FunctionType(returnType, paramTypes, false), c.funcPtrAddrSpace)
+	return llvm.FunctionType(returnType, paramTypes, false)
 }
 
 // parseMakeClosure makes a function value (with context) from the given
@@ -141,5 +143,6 @@ func (b *builder) parseMakeClosure(expr *ssa.MakeClosure) (llvm.Value, error) {
 	context := b.emitPointerPack(boundVars)
 
 	// Create the closure.
-	return b.createFuncValue(b.getFunction(f), context, f.Signature), nil
+	_, fn := b.getFunction(f)
+	return b.createFuncValue(fn, context, f.Signature), nil
 }

compiler/gc.go

@@ -84,7 +84,7 @@ func (b *builder) trackPointer(value llvm.Value) {
 	if value.Type() != b.i8ptrType {
 		value = b.CreateBitCast(value, b.i8ptrType, "")
 	}
-	b.createRuntimeCall("trackPointer", []llvm.Value{value}, "")
+	b.createRuntimeCall("trackPointer", []llvm.Value{value, b.stackChainAlloca}, "")
 }
 
 // typeHasPointers returns whether this type is a pointer or contains pointers.

compiler/goroutine.go

@@ -7,7 +7,6 @@ import (
 	"go/token"
 	"go/types"
 
-	"github.com/tinygo-org/tinygo/compiler/llvmutil"
 	"golang.org/x/tools/go/ssa"
 	"tinygo.org/x/go-llvm"
 )
@@ -22,6 +21,7 @@ func (b *builder) createGo(instr *ssa.Go) {
 
 	var prefix string
 	var funcPtr llvm.Value
+	var funcPtrType llvm.Type
 	hasContext := false
 	if callee := instr.Call.StaticCallee(); callee != nil {
 		// Static callee is known. This makes it easier to start a new
@@ -42,7 +42,7 @@ func (b *builder) createGo(instr *ssa.Go) {
 			params = append(params, context) // context parameter
 			hasContext = true
 		}
-		funcPtr = b.getFunction(callee)
+		funcPtrType, funcPtr = b.getFunction(callee)
 	} else if builtin, ok := instr.Call.Value.(*ssa.Builtin); ok {
 		// We cheat. None of the builtins do any long or blocking operation, so
 		// we might as well run these builtins right away without the program
@@ -80,6 +80,7 @@ func (b *builder) createGo(instr *ssa.Go) {
 		itfTypeCode := b.CreateExtractValue(itf, 0, "")
 		itfValue := b.CreateExtractValue(itf, 1, "")
 		funcPtr = b.getInvokeFunction(&instr.Call)
+		funcPtrType = funcPtr.GlobalValueType()
 		params = append([]llvm.Value{itfValue}, params...) // start with receiver
 		params = append(params, itfTypeCode)               // end with typecode
 	} else {
@@ -89,7 +90,7 @@ func (b *builder) createGo(instr *ssa.Go) {
 		//   * The function context, for closures.
 		//   * The function pointer (for tasks).
 		var context llvm.Value
-		funcPtr, context = b.decodeFuncValue(b.getValue(instr.Call.Value), instr.Call.Value.Type().Underlying().(*types.Signature))
+		funcPtrType, funcPtr, context = b.decodeFuncValue(b.getValue(instr.Call.Value), instr.Call.Value.Type().Underlying().(*types.Signature))
 		params = append(params, context, funcPtr)
 		hasContext = true
 		prefix = b.fn.RelString(nil)
@@ -97,14 +98,14 @@ func (b *builder) createGo(instr *ssa.Go) {
 
 	paramBundle := b.emitPointerPack(params)
 	var stackSize llvm.Value
-	callee := b.createGoroutineStartWrapper(funcPtr, prefix, hasContext, instr.Pos())
+	callee := b.createGoroutineStartWrapper(funcPtrType, funcPtr, prefix, hasContext, instr.Pos())
 	if b.AutomaticStackSize {
 		// The stack size is not known until after linking. Call a dummy
 		// function that will be replaced with a load from a special ELF
 		// section that contains the stack size (and is modified after
 		// linking).
-		stackSizeFn := b.getFunction(b.program.ImportedPackage("internal/task").Members["getGoroutineStackSize"].(*ssa.Function))
+		stackSizeFnType, stackSizeFn := b.getFunction(b.program.ImportedPackage("internal/task").Members["getGoroutineStackSize"].(*ssa.Function))
-		stackSize = b.createCall(stackSizeFn, []llvm.Value{callee, llvm.Undef(b.i8ptrType)}, "stacksize")
+		stackSize = b.createCall(stackSizeFnType, stackSizeFn, []llvm.Value{callee, llvm.Undef(b.i8ptrType)}, "stacksize")
 	} else {
 		// The stack size is fixed at compile time. By emitting it here as a
 		// constant, it can be optimized.
@@ -113,8 +114,8 @@ func (b *builder) createGo(instr *ssa.Go) {
 		}
 		stackSize = llvm.ConstInt(b.uintptrType, b.DefaultStackSize, false)
 	}
-	start := b.getFunction(b.program.ImportedPackage("internal/task").Members["start"].(*ssa.Function))
+	fnType, start := b.getFunction(b.program.ImportedPackage("internal/task").Members["start"].(*ssa.Function))
-	b.createCall(start, []llvm.Value{callee, paramBundle, stackSize, llvm.Undef(b.i8ptrType)}, "")
+	b.createCall(fnType, start, []llvm.Value{callee, paramBundle, stackSize, llvm.Undef(b.i8ptrType)}, "")
 }
 
 // createGoroutineStartWrapper creates a wrapper for the task-based
@@ -140,15 +141,19 @@ func (b *builder) createGo(instr *ssa.Go) {
 // to last parameter of the function) is used for this wrapper. If hasContext is
 // false, the parameter bundle is assumed to have no context parameter and undef
 // is passed instead.
-func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix string, hasContext bool, pos token.Pos) llvm.Value {
+func (c *compilerContext) createGoroutineStartWrapper(fnType llvm.Type, fn llvm.Value, prefix string, hasContext bool, pos token.Pos) llvm.Value {
 	var wrapper llvm.Value
 
-	builder := c.ctx.NewBuilder()
+	b := &builder{
-	defer builder.Dispose()
+		compilerContext: c,
+		Builder:         c.ctx.NewBuilder(),
+	}
+	defer b.Dispose()
 
 	var deadlock llvm.Value
+	var deadlockType llvm.Type
 	if c.Scheduler == "asyncify" {
-		deadlock = c.getFunction(c.program.ImportedPackage("runtime").Members["deadlock"].(*ssa.Function))
+		deadlockType, deadlock = c.getFunction(c.program.ImportedPackage("runtime").Members["deadlock"].(*ssa.Function))
 	}
 
 	if !fn.IsAFunction().IsNil() {
@@ -167,7 +172,7 @@ func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix stri
 		wrapper.SetUnnamedAddr(true)
 		wrapper.AddAttributeAtIndex(-1, c.ctx.CreateStringAttribute("tinygo-gowrapper", name))
 		entry := c.ctx.AddBasicBlock(wrapper, "entry")
-		builder.SetInsertPointAtEnd(entry)
+		b.SetInsertPointAtEnd(entry)
 
 		if c.Debug {
 			pos := c.program.Fset.Position(pos)
@@ -188,24 +193,24 @@ func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix stri
 				Optimized:    true,
 			})
 			wrapper.SetSubprogram(difunc)
-			builder.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), difunc, llvm.Metadata{})
+			b.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), difunc, llvm.Metadata{})
 		}
 
 		// Create the list of params for the call.
-		paramTypes := fn.Type().ElementType().ParamTypes()
+		paramTypes := fnType.ParamTypes()
 		if !hasContext {
 			paramTypes = paramTypes[:len(paramTypes)-1] // strip context parameter
 		}
-		params := llvmutil.EmitPointerUnpack(builder, c.mod, wrapper.Param(0), paramTypes)
+		params := b.emitPointerUnpack(wrapper.Param(0), paramTypes)
 		if !hasContext {
 			params = append(params, llvm.Undef(c.i8ptrType)) // add dummy context parameter
 		}
 
 		// Create the call.
-		builder.CreateCall(fn, params, "")
+		b.CreateCall(fnType, fn, params, "")
 
 		if c.Scheduler == "asyncify" {
-			builder.CreateCall(deadlock, []llvm.Value{
+			b.CreateCall(deadlockType, deadlock, []llvm.Value{
 				llvm.Undef(c.i8ptrType),
 			}, "")
 		}
@@ -236,7 +241,7 @@ func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix stri
 		wrapper.SetUnnamedAddr(true)
 		wrapper.AddAttributeAtIndex(-1, c.ctx.CreateStringAttribute("tinygo-gowrapper", ""))
 		entry := c.ctx.AddBasicBlock(wrapper, "entry")
-		builder.SetInsertPointAtEnd(entry)
+		b.SetInsertPointAtEnd(entry)
 
 		if c.Debug {
 			pos := c.program.Fset.Position(pos)
@@ -257,23 +262,23 @@ func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix stri
 				Optimized:    true,
 			})
 			wrapper.SetSubprogram(difunc)
-			builder.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), difunc, llvm.Metadata{})
+			b.SetCurrentDebugLocation(uint(pos.Line), uint(pos.Column), difunc, llvm.Metadata{})
 		}
 
 		// Get the list of parameters, with the extra parameters at the end.
-		paramTypes := fn.Type().ElementType().ParamTypes()
+		paramTypes := fnType.ParamTypes()
 		paramTypes = append(paramTypes, fn.Type()) // the last element is the function pointer
-		params := llvmutil.EmitPointerUnpack(builder, c.mod, wrapper.Param(0), paramTypes)
+		params := b.emitPointerUnpack(wrapper.Param(0), paramTypes)
 
 		// Get the function pointer.
 		fnPtr := params[len(params)-1]
 		params = params[:len(params)-1]
 
 		// Create the call.
-		builder.CreateCall(fnPtr, params, "")
+		b.CreateCall(fnType, fnPtr, params, "")
 
 		if c.Scheduler == "asyncify" {
-			builder.CreateCall(deadlock, []llvm.Value{
+			b.CreateCall(deadlockType, deadlock, []llvm.Value{
 				llvm.Undef(c.i8ptrType),
 			}, "")
 		}
@@ -281,13 +286,13 @@ func (c *compilerContext) createGoroutineStartWrapper(fn llvm.Value, prefix stri
 
 	if c.Scheduler == "asyncify" {
 		// The goroutine was terminated via deadlock.
-		builder.CreateUnreachable()
+		b.CreateUnreachable()
 	} else {
 		// Finish the function. Every basic block must end in a terminator, and
 		// because goroutines never return a value we can simply return void.
-		builder.CreateRetVoid()
+		b.CreateRetVoid()
 	}
 
 	// Return a ptrtoint of the wrapper, not the function itself.
-	return builder.CreatePtrToInt(wrapper, c.uintptrType, "")
+	return b.CreatePtrToInt(wrapper, c.uintptrType, "")
 }

compiler/inlineasm.go

@@ -25,7 +25,7 @@ func (b *builder) createInlineAsm(args []ssa.Value) (llvm.Value, error) {
 	fnType := llvm.FunctionType(b.ctx.VoidType(), []llvm.Type{}, false)
 	asm := constant.StringVal(args[0].(*ssa.Const).Value)
 	target := llvm.InlineAsm(fnType, asm, "", true, false, 0, false)
-	return b.CreateCall(target, nil, ""), nil
+	return b.CreateCall(fnType, target, nil, ""), nil
 }
 
 // This is a compiler builtin, which allows assembly to be called in a flexible
@@ -120,7 +120,7 @@ func (b *builder) createInlineAsmFull(instr *ssa.CallCommon) (llvm.Value, error)
 	}
 	fnType := llvm.FunctionType(outputType, argTypes, false)
 	target := llvm.InlineAsm(fnType, asmString, strings.Join(constraints, ","), true, false, 0, false)
-	result := b.CreateCall(target, args, "")
+	result := b.CreateCall(fnType, target, args, "")
 	if hasOutput {
 		return result, nil
 	} else {
@@ -163,7 +163,7 @@ func (b *builder) emitSVCall(args []ssa.Value) (llvm.Value, error) {
 	constraints += ",~{r1},~{r2},~{r3}"
 	fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
 	target := llvm.InlineAsm(fnType, asm, constraints, true, false, 0, false)
-	return b.CreateCall(target, llvmArgs, ""), nil
+	return b.CreateCall(fnType, target, llvmArgs, ""), nil
 }
 
 // This is a compiler builtin which emits an inline SVCall instruction. It can
@@ -201,7 +201,7 @@ func (b *builder) emitSV64Call(args []ssa.Value) (llvm.Value, error) {
 	constraints += ",~{x1},~{x2},~{x3},~{x4},~{x5},~{x6},~{x7}"
 	fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
 	target := llvm.InlineAsm(fnType, asm, constraints, true, false, 0, false)
-	return b.CreateCall(target, llvmArgs, ""), nil
+	return b.CreateCall(fnType, target, llvmArgs, ""), nil
 }
 
 // This is a compiler builtin which emits CSR instructions. It can be one of:
@@ -226,24 +226,24 @@ func (b *builder) emitCSROperation(call *ssa.CallCommon) (llvm.Value, error) {
 		fnType := llvm.FunctionType(b.uintptrType, nil, false)
 		asm := fmt.Sprintf("csrr $0, %d", csr)
 		target := llvm.InlineAsm(fnType, asm, "=r", true, false, 0, false)
-		return b.CreateCall(target, nil, ""), nil
+		return b.CreateCall(fnType, target, nil, ""), nil
 	case "Set":
 		fnType := llvm.FunctionType(b.ctx.VoidType(), []llvm.Type{b.uintptrType}, false)
 		asm := fmt.Sprintf("csrw %d, $0", csr)
 		target := llvm.InlineAsm(fnType, asm, "r", true, false, 0, false)
-		return b.CreateCall(target, []llvm.Value{b.getValue(call.Args[1])}, ""), nil
+		return b.CreateCall(fnType, target, []llvm.Value{b.getValue(call.Args[1])}, ""), nil
 	case "SetBits":
 		// Note: it may be possible to optimize this to csrrsi in many cases.
 		fnType := llvm.FunctionType(b.uintptrType, []llvm.Type{b.uintptrType}, false)
 		asm := fmt.Sprintf("csrrs $0, %d, $1", csr)
 		target := llvm.InlineAsm(fnType, asm, "=r,r", true, false, 0, false)
-		return b.CreateCall(target, []llvm.Value{b.getValue(call.Args[1])}, ""), nil
+		return b.CreateCall(fnType, target, []llvm.Value{b.getValue(call.Args[1])}, ""), nil
 	case "ClearBits":
 		// Note: it may be possible to optimize this to csrrci in many cases.
 		fnType := llvm.FunctionType(b.uintptrType, []llvm.Type{b.uintptrType}, false)
 		asm := fmt.Sprintf("csrrc $0, %d, $1", csr)
 		target := llvm.InlineAsm(fnType, asm, "=r,r", true, false, 0, false)
-		return b.CreateCall(target, []llvm.Value{b.getValue(call.Args[1])}, ""), nil
+		return b.CreateCall(fnType, target, []llvm.Value{b.getValue(call.Args[1])}, ""), nil
 	default:
 		return llvm.Value{}, b.makeError(call.Pos(), "unknown CSR operation: "+name)
 	}

compiler/interface.go

@@ -86,22 +86,22 @@ func (c *compilerContext) getTypeCode(typ types.Type) llvm.Value {
 		if _, ok := typ.Underlying().(*types.Pointer); !ok {
 			ptrTo = c.getTypeCode(types.NewPointer(typ))
 		}
-		globalValue := llvm.ConstNull(global.Type().ElementType())
+		globalValue := llvm.ConstNull(global.GlobalValueType())
 		if !references.IsNil() {
-			globalValue = llvm.ConstInsertValue(globalValue, references, []uint32{0})
+			globalValue = c.builder.CreateInsertValue(globalValue, references, 0, "")
 		}
 		if length != 0 {
 			lengthValue := llvm.ConstInt(c.uintptrType, uint64(length), false)
-			globalValue = llvm.ConstInsertValue(globalValue, lengthValue, []uint32{1})
+			globalValue = c.builder.CreateInsertValue(globalValue, lengthValue, 1, "")
 		}
 		if !methodSet.IsNil() {
-			globalValue = llvm.ConstInsertValue(globalValue, methodSet, []uint32{2})
+			globalValue = c.builder.CreateInsertValue(globalValue, methodSet, 2, "")
 		}
 		if !ptrTo.IsNil() {
-			globalValue = llvm.ConstInsertValue(globalValue, ptrTo, []uint32{3})
+			globalValue = c.builder.CreateInsertValue(globalValue, ptrTo, 3, "")
 		}
 		if !typeAssert.IsNil() {
-			globalValue = llvm.ConstInsertValue(globalValue, typeAssert, []uint32{4})
+			globalValue = c.builder.CreateInsertValue(globalValue, typeAssert, 4, "")
 		}
 		global.SetInitializer(globalValue)
 		global.SetLinkage(llvm.LinkOnceODRLinkage)
@@ -121,30 +121,30 @@ func (c *compilerContext) makeStructTypeFields(typ *types.Struct) llvm.Value {
 	structGlobalValue := llvm.ConstNull(structGlobalType)
 	for i := 0; i < typ.NumFields(); i++ {
 		fieldGlobalValue := llvm.ConstNull(runtimeStructField)
-		fieldGlobalValue = llvm.ConstInsertValue(fieldGlobalValue, c.getTypeCode(typ.Field(i).Type()), []uint32{0})
+		fieldGlobalValue = c.builder.CreateInsertValue(fieldGlobalValue, c.getTypeCode(typ.Field(i).Type()), 0, "")
-		fieldName := c.makeGlobalArray([]byte(typ.Field(i).Name()), "reflect/types.structFieldName", c.ctx.Int8Type())
+		fieldNameType, fieldName := c.makeGlobalArray([]byte(typ.Field(i).Name()), "reflect/types.structFieldName", c.ctx.Int8Type())
 		fieldName.SetLinkage(llvm.PrivateLinkage)
 		fieldName.SetUnnamedAddr(true)
-		fieldName = llvm.ConstGEP(fieldName, []llvm.Value{
+		fieldName = llvm.ConstGEP(fieldNameType, fieldName, []llvm.Value{
 			llvm.ConstInt(c.ctx.Int32Type(), 0, false),
 			llvm.ConstInt(c.ctx.Int32Type(), 0, false),
 		})
-		fieldGlobalValue = llvm.ConstInsertValue(fieldGlobalValue, fieldName, []uint32{1})
+		fieldGlobalValue = c.builder.CreateInsertValue(fieldGlobalValue, fieldName, 1, "")
 		if typ.Tag(i) != "" {
-			fieldTag := c.makeGlobalArray([]byte(typ.Tag(i)), "reflect/types.structFieldTag", c.ctx.Int8Type())
+			fieldTagType, fieldTag := c.makeGlobalArray([]byte(typ.Tag(i)), "reflect/types.structFieldTag", c.ctx.Int8Type())
 			fieldTag.SetLinkage(llvm.PrivateLinkage)
 			fieldTag.SetUnnamedAddr(true)
-			fieldTag = llvm.ConstGEP(fieldTag, []llvm.Value{
+			fieldTag = llvm.ConstGEP(fieldTagType, fieldTag, []llvm.Value{
 				llvm.ConstInt(c.ctx.Int32Type(), 0, false),
 				llvm.ConstInt(c.ctx.Int32Type(), 0, false),
 			})
-			fieldGlobalValue = llvm.ConstInsertValue(fieldGlobalValue, fieldTag, []uint32{2})
+			fieldGlobalValue = c.builder.CreateInsertValue(fieldGlobalValue, fieldTag, 2, "")
 		}
 		if typ.Field(i).Embedded() {
 			fieldEmbedded := llvm.ConstInt(c.ctx.Int1Type(), 1, false)
-			fieldGlobalValue = llvm.ConstInsertValue(fieldGlobalValue, fieldEmbedded, []uint32{3})
+			fieldGlobalValue = c.builder.CreateInsertValue(fieldGlobalValue, fieldEmbedded, 3, "")
 		}
-		structGlobalValue = llvm.ConstInsertValue(structGlobalValue, fieldGlobalValue, []uint32{uint32(i)})
+		structGlobalValue = c.builder.CreateInsertValue(structGlobalValue, fieldGlobalValue, i, "")
 	}
 	structGlobal.SetInitializer(structGlobalValue)
 	structGlobal.SetUnnamedAddr(true)
@@ -239,7 +239,7 @@ func (c *compilerContext) getTypeMethodSet(typ types.Type) llvm.Value {
 	zero := llvm.ConstInt(c.ctx.Int32Type(), 0, false)
 	if !global.IsNil() {
 		// the method set already exists
-		return llvm.ConstGEP(global, []llvm.Value{zero, zero})
+		return llvm.ConstGEP(global.GlobalValueType(), global, []llvm.Value{zero, zero})
 	}
 
 	ms := c.program.MethodSets.MethodSet(typ)
@@ -254,12 +254,12 @@ func (c *compilerContext) getTypeMethodSet(typ types.Type) llvm.Value {
 		method := ms.At(i)
 		signatureGlobal := c.getMethodSignature(method.Obj().(*types.Func))
 		fn := c.program.MethodValue(method)
-		llvmFn := c.getFunction(fn)
+		llvmFnType, llvmFn := c.getFunction(fn)
 		if llvmFn.IsNil() {
 			// compiler error, so panic
 			panic("cannot find function: " + c.getFunctionInfo(fn).linkName)
 		}
-		wrapper := c.getInterfaceInvokeWrapper(fn, llvmFn)
+		wrapper := c.getInterfaceInvokeWrapper(fn, llvmFnType, llvmFn)
 		methodInfo := llvm.ConstNamedStruct(interfaceMethodInfoType, []llvm.Value{
 			signatureGlobal,
 			llvm.ConstPtrToInt(wrapper, c.uintptrType),
@@ -272,7 +272,7 @@ func (c *compilerContext) getTypeMethodSet(typ types.Type) llvm.Value {
 	global.SetInitializer(value)
 	global.SetGlobalConstant(true)
 	global.SetLinkage(llvm.LinkOnceODRLinkage)
-	return llvm.ConstGEP(global, []llvm.Value{zero, zero})
+	return llvm.ConstGEP(arrayType, global, []llvm.Value{zero, zero})
 }
 
 // getInterfaceMethodSet returns a global variable with the method set of the
@@ -288,7 +288,7 @@ func (c *compilerContext) getInterfaceMethodSet(typ types.Type) llvm.Value {
 	zero := llvm.ConstInt(c.ctx.Int32Type(), 0, false)
 	if !global.IsNil() {
 		// method set already exist, return it
-		return llvm.ConstGEP(global, []llvm.Value{zero, zero})
+		return llvm.ConstGEP(global.GlobalValueType(), global, []llvm.Value{zero, zero})
 	}
 
 	// Every method is a *i8 reference indicating the signature of this method.
@@ -303,7 +303,7 @@ func (c *compilerContext) getInterfaceMethodSet(typ types.Type) llvm.Value {
 	global.SetInitializer(value)
 	global.SetGlobalConstant(true)
 	global.SetLinkage(llvm.LinkOnceODRLinkage)
-	return llvm.ConstGEP(global, []llvm.Value{zero, zero})
+	return llvm.ConstGEP(value.Type(), global, []llvm.Value{zero, zero})
 }
 
 // getMethodSignatureName returns a unique name (that can be used as the name of
@@ -361,7 +361,7 @@ func (b *builder) createTypeAssert(expr *ssa.TypeAssert) llvm.Value {
 		// implements each method of the interface. See:
 		// https://research.swtch.com/interfaces
 		fn := b.getInterfaceImplementsFunc(expr.AssertedType)
-		commaOk = b.CreateCall(fn, []llvm.Value{actualTypeNum}, "")
+		commaOk = b.CreateCall(fn.GlobalValueType(), fn, []llvm.Value{actualTypeNum}, "")
 
 	} else {
 		globalName := "reflect/types.typeid:" + getTypeCodeName(expr.AssertedType)
@@ -465,7 +465,7 @@ func (c *compilerContext) getInvokeFunction(instr *ssa.CallCommon) llvm.Value {
 			paramTuple = append(paramTuple, sig.Params().At(i))
 		}
 		paramTuple = append(paramTuple, types.NewVar(token.NoPos, nil, "$typecode", types.Typ[types.Uintptr]))
-		llvmFnType := c.getRawFuncType(types.NewSignature(sig.Recv(), types.NewTuple(paramTuple...), sig.Results(), false)).ElementType()
+		llvmFnType := c.getRawFuncType(types.NewSignature(sig.Recv(), types.NewTuple(paramTuple...), sig.Results(), false))
 		llvmFn = llvm.AddFunction(c.mod, fnName, llvmFnType)
 		c.addStandardDeclaredAttributes(llvmFn)
 		llvmFn.AddFunctionAttr(c.ctx.CreateStringAttribute("tinygo-invoke", c.getMethodSignatureName(instr.Method)))
@@ -480,7 +480,7 @@ func (c *compilerContext) getInvokeFunction(instr *ssa.CallCommon) llvm.Value {
 // value, dereferences or unpacks it if necessary, and calls the real method.
 // If the method to wrap has a pointer receiver, no wrapping is necessary and
 // the function is returned directly.
-func (c *compilerContext) getInterfaceInvokeWrapper(fn *ssa.Function, llvmFn llvm.Value) llvm.Value {
+func (c *compilerContext) getInterfaceInvokeWrapper(fn *ssa.Function, llvmFnType llvm.Type, llvmFn llvm.Value) llvm.Value {
 	wrapperName := llvmFn.Name() + "$invoke"
 	wrapper := c.mod.NamedFunction(wrapperName)
 	if !wrapper.IsNil() {
@@ -505,9 +505,8 @@ func (c *compilerContext) getInterfaceInvokeWrapper(fn *ssa.Function, llvmFn llv
 	}
 
 	// create wrapper function
-	fnType := llvmFn.Type().ElementType()
+	paramTypes := append([]llvm.Type{c.i8ptrType}, llvmFnType.ParamTypes()[len(expandedReceiverType):]...)
-	paramTypes := append([]llvm.Type{c.i8ptrType}, fnType.ParamTypes()[len(expandedReceiverType):]...)
+	wrapFnType := llvm.FunctionType(llvmFnType.ReturnType(), paramTypes, false)
-	wrapFnType := llvm.FunctionType(fnType.ReturnType(), paramTypes, false)
 	wrapper = llvm.AddFunction(c.mod, wrapperName, wrapFnType)
 	c.addStandardAttributes(wrapper)
 
@@ -534,11 +533,11 @@ func (c *compilerContext) getInterfaceInvokeWrapper(fn *ssa.Function, llvmFn llv
 
 	receiverValue := b.emitPointerUnpack(wrapper.Param(0), []llvm.Type{receiverType})[0]
 	params := append(b.expandFormalParam(receiverValue), wrapper.Params()[1:]...)
-	if llvmFn.Type().ElementType().ReturnType().TypeKind() == llvm.VoidTypeKind {
+	if llvmFnType.ReturnType().TypeKind() == llvm.VoidTypeKind {
-		b.CreateCall(llvmFn, params, "")
+		b.CreateCall(llvmFnType, llvmFn, params, "")
 		b.CreateRetVoid()
 	} else {
-		ret := b.CreateCall(llvmFn, params, "ret")
+		ret := b.CreateCall(llvmFnType, llvmFn, params, "ret")
 		b.CreateRet(ret)
 	}
 

compiler/interrupt.go

@@ -36,7 +36,7 @@ func (b *builder) createInterruptGlobal(instr *ssa.CallCommon) (llvm.Value, erro
 		// Fall back to a generic error.
 		return llvm.Value{}, b.makeError(instr.Pos(), "interrupt function must be constant")
 	}
-	funcRawPtr, funcContext := b.decodeFuncValue(funcValue, nil)
+	_, funcRawPtr, funcContext := b.decodeFuncValue(funcValue, nil)
 	funcPtr := llvm.ConstPtrToInt(funcRawPtr, b.uintptrType)
 
 	// Create a new global of type runtime/interrupt.handle. Globals of this
@@ -49,9 +49,11 @@ func (b *builder) createInterruptGlobal(instr *ssa.CallCommon) (llvm.Value, erro
 	global.SetGlobalConstant(true)
 	global.SetUnnamedAddr(true)
 	initializer := llvm.ConstNull(globalLLVMType)
-	initializer = llvm.ConstInsertValue(initializer, funcContext, []uint32{0})
+	initializer = b.CreateInsertValue(initializer, funcContext, 0, "")
-	initializer = llvm.ConstInsertValue(initializer, funcPtr, []uint32{1})
+	initializer = b.CreateInsertValue(initializer, funcPtr, 1, "")
-	initializer = llvm.ConstInsertValue(initializer, llvm.ConstInt(b.intType, uint64(id.Int64()), true), []uint32{2, 0})
+	initializer = b.CreateInsertValue(initializer, llvm.ConstNamedStruct(globalLLVMType.StructElementTypes()[2], []llvm.Value{
+		llvm.ConstInt(b.intType, uint64(id.Int64()), true),
+	}), 2, "")
 	global.SetInitializer(initializer)
 
 	// Add debug info to the interrupt global.
@@ -85,7 +87,7 @@ func (b *builder) createInterruptGlobal(instr *ssa.CallCommon) (llvm.Value, erro
 			useFnType := llvm.FunctionType(b.ctx.VoidType(), []llvm.Type{interrupt.Type()}, false)
 			useFn = llvm.AddFunction(b.mod, "runtime/interrupt.use", useFnType)
 		}
-		b.CreateCall(useFn, []llvm.Value{interrupt}, "")
+		b.CreateCall(useFn.GlobalValueType(), useFn, []llvm.Value{interrupt}, "")
 	}
 
 	return interrupt, nil

compiler/intrinsics.go

@@ -7,6 +7,7 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/tinygo-org/tinygo/compiler/llvmutil"
 	"tinygo.org/x/go-llvm"
 )
 
@@ -44,7 +45,10 @@ func (b *builder) defineIntrinsicFunction() {
 // and will otherwise be lowered to regular libc memcpy/memmove calls.
 func (b *builder) createMemoryCopyImpl() {
 	b.createFunctionStart(true)
-	fnName := "llvm." + b.fn.Name() + ".p0i8.p0i8.i" + strconv.Itoa(b.uintptrType.IntTypeWidth())
+	fnName := "llvm." + b.fn.Name() + ".p0.p0.i" + strconv.Itoa(b.uintptrType.IntTypeWidth())
+	if llvmutil.Major() < 15 { // compatibility with LLVM 14
+		fnName = "llvm." + b.fn.Name() + ".p0i8.p0i8.i" + strconv.Itoa(b.uintptrType.IntTypeWidth())
+	}
 	llvmFn := b.mod.NamedFunction(fnName)
 	if llvmFn.IsNil() {
 		fnType := llvm.FunctionType(b.ctx.VoidType(), []llvm.Type{b.i8ptrType, b.i8ptrType, b.uintptrType, b.ctx.Int1Type()}, false)
@@ -55,7 +59,7 @@ func (b *builder) createMemoryCopyImpl() {
 		params = append(params, b.getValue(param))
 	}
 	params = append(params, llvm.ConstInt(b.ctx.Int1Type(), 0, false))
-	b.CreateCall(llvmFn, params, "")
+	b.CreateCall(llvmFn.GlobalValueType(), llvmFn, params, "")
 	b.CreateRetVoid()
 }
 
@@ -64,7 +68,10 @@ func (b *builder) createMemoryCopyImpl() {
 // regular libc memset calls if they aren't optimized out in a different way.
 func (b *builder) createMemoryZeroImpl() {
 	b.createFunctionStart(true)
-	fnName := "llvm.memset.p0i8.i" + strconv.Itoa(b.uintptrType.IntTypeWidth())
+	fnName := "llvm.memset.p0.i" + strconv.Itoa(b.uintptrType.IntTypeWidth())
+	if llvmutil.Major() < 15 { // compatibility with LLVM 14
+		fnName = "llvm.memset.p0i8.i" + strconv.Itoa(b.uintptrType.IntTypeWidth())
+	}
 	llvmFn := b.mod.NamedFunction(fnName)
 	if llvmFn.IsNil() {
 		fnType := llvm.FunctionType(b.ctx.VoidType(), []llvm.Type{b.i8ptrType, b.ctx.Int8Type(), b.uintptrType, b.ctx.Int1Type()}, false)
@@ -76,7 +83,7 @@ func (b *builder) createMemoryZeroImpl() {
 		b.getValue(b.fn.Params[1]),
 		llvm.ConstInt(b.ctx.Int1Type(), 0, false),
 	}
-	b.CreateCall(llvmFn, params, "")
+	b.CreateCall(llvmFn.GlobalValueType(), llvmFn, params, "")
 	b.CreateRetVoid()
 }
 
@@ -119,6 +126,6 @@ func (b *builder) defineMathOp() {
 	for i, param := range b.fn.Params {
 		args[i] = b.getValue(param)
 	}
-	result := b.CreateCall(llvmFn, args, "")
+	result := b.CreateCall(llvmFn.GlobalValueType(), llvmFn, args, "")
 	b.CreateRet(result)
 }

compiler/ircheck/check.go

@@ -70,10 +70,7 @@ func (c *checker) checkType(t llvm.Type, checked map[llvm.Type]struct{}, special
 			return fmt.Errorf("failed to verify element type of array type %s: %s", t.String(), err.Error())
 		}
 	case llvm.PointerTypeKind:
-		// check underlying type
+		// Pointers can't be checked in an opaque pointer world.
-		if err := c.checkType(t.ElementType(), checked, specials); err != nil {
-			return fmt.Errorf("failed to verify underlying type of pointer type %s: %s", t.String(), err.Error())
-		}
 	case llvm.VectorTypeKind:
 		// check element type
 		if err := c.checkType(t.ElementType(), checked, specials); err != nil {

compiler/llvm.go

@@ -51,29 +51,175 @@ func (b *builder) emitLifetimeEnd(ptr, size llvm.Value) {
 // emitPointerPack packs the list of values into a single pointer value using
 // bitcasts, or else allocates a value on the heap if it cannot be packed in the
 // 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) llvm.Value {
-	return llvmutil.EmitPointerPack(b.Builder, b.mod, b.pkg.Path(), b.NeedsStackObjects, values)
+	valueTypes := make([]llvm.Type, len(values))
+	for i, value := range values {
+		valueTypes[i] = value.Type()
+	}
+	packedType := b.ctx.StructType(valueTypes, false)
+
+	// Allocate memory for the packed data.
+	size := b.targetData.TypeAllocSize(packedType)
+	if size == 0 {
+		return llvm.ConstPointerNull(b.i8ptrType)
+	} else if len(values) == 1 && values[0].Type().TypeKind() == llvm.PointerTypeKind {
+		return b.CreateBitCast(values[0], b.i8ptrType, "pack.ptr")
+	} else if size <= b.targetData.TypeAllocSize(b.i8ptrType) {
+		// Packed data fits in a pointer, so store it directly inside the
+		// pointer.
+		if len(values) == 1 && values[0].Type().TypeKind() == llvm.IntegerTypeKind {
+			// Try to keep this cast in SSA form.
+			return b.CreateIntToPtr(values[0], b.i8ptrType, "pack.int")
+		}
+
+		// Because packedType is a struct and we have to cast it to a *i8, store
+		// it in a *i8 alloca first and load the *i8 value from there. This is
+		// effectively a bitcast.
+		packedAlloc, _, _ := b.createTemporaryAlloca(b.i8ptrType, "")
+
+		if size < b.targetData.TypeAllocSize(b.i8ptrType) {
+			// The alloca is bigger than the value that will be stored in it.
+			// To avoid having some bits undefined, zero the alloca first.
+			// Hopefully this will get optimized away.
+			b.CreateStore(llvm.ConstNull(b.i8ptrType), packedAlloc)
+		}
+
+		// Store all values in the alloca.
+		packedAllocCast := b.CreateBitCast(packedAlloc, llvm.PointerType(packedType, 0), "")
+		for i, value := range values {
+			indices := []llvm.Value{
+				llvm.ConstInt(b.ctx.Int32Type(), 0, false),
+				llvm.ConstInt(b.ctx.Int32Type(), uint64(i), false),
+			}
+			gep := b.CreateInBoundsGEP(packedType, packedAllocCast, indices, "")
+			b.CreateStore(value, gep)
+		}
+
+		// Load value (the *i8) from the alloca.
+		result := b.CreateLoad(b.i8ptrType, packedAlloc, "")
+
+		// End the lifetime of the alloca, to help the optimizer.
+		packedPtr := b.CreateBitCast(packedAlloc, b.i8ptrType, "")
+		packedSize := llvm.ConstInt(b.ctx.Int64Type(), b.targetData.TypeAllocSize(packedAlloc.Type()), false)
+		b.emitLifetimeEnd(packedPtr, packedSize)
+
+		return result
+	} else {
+		// Check if the values are all constants.
+		constant := true
+		for _, v := range values {
+			if !v.IsConstant() {
+				constant = false
+				break
+			}
+		}
+
+		if constant {
+			// The data is known at compile time, so store it in a constant global.
+			// The global address is marked as unnamed, which allows LLVM to merge duplicates.
+			global := llvm.AddGlobal(b.mod, packedType, b.pkg.Path()+"$pack")
+			global.SetInitializer(b.ctx.ConstStruct(values, false))
+			global.SetGlobalConstant(true)
+			global.SetUnnamedAddr(true)
+			global.SetLinkage(llvm.InternalLinkage)
+			return llvm.ConstBitCast(global, b.i8ptrType)
+		}
+
+		// Packed data is bigger than a pointer, so allocate it on the heap.
+		sizeValue := llvm.ConstInt(b.uintptrType, size, false)
+		alloc := b.mod.NamedFunction("runtime.alloc")
+		packedHeapAlloc := b.CreateCall(alloc.GlobalValueType(), alloc, []llvm.Value{
+			sizeValue,
+			llvm.ConstNull(b.i8ptrType),
+			llvm.Undef(b.i8ptrType), // unused context parameter
+		}, "")
+		if b.NeedsStackObjects {
+			b.trackPointer(packedHeapAlloc)
+		}
+		packedAlloc := b.CreateBitCast(packedHeapAlloc, llvm.PointerType(packedType, 0), "")
+
+		// Store all values in the heap pointer.
+		for i, value := range values {
+			indices := []llvm.Value{
+				llvm.ConstInt(b.ctx.Int32Type(), 0, false),
+				llvm.ConstInt(b.ctx.Int32Type(), uint64(i), false),
+			}
+			gep := b.CreateInBoundsGEP(packedType, packedAlloc, indices, "")
+			b.CreateStore(value, gep)
+		}
+
+		// Return the original heap allocation pointer, which already is an *i8.
+		return packedHeapAlloc
+	}
 }
 
 // emitPointerUnpack extracts a list of values packed using emitPointerPack.
 func (b *builder) emitPointerUnpack(ptr llvm.Value, valueTypes []llvm.Type) []llvm.Value {
-	return llvmutil.EmitPointerUnpack(b.Builder, b.mod, ptr, valueTypes)
+	packedType := b.ctx.StructType(valueTypes, false)
+
+	// Get a correctly-typed pointer to the packed data.
+	var packedAlloc, packedRawAlloc llvm.Value
+	size := b.targetData.TypeAllocSize(packedType)
+	if size == 0 {
+		// No data to unpack.
+	} else if len(valueTypes) == 1 && valueTypes[0].TypeKind() == llvm.PointerTypeKind {
+		// A single pointer is always stored directly.
+		return []llvm.Value{b.CreateBitCast(ptr, valueTypes[0], "unpack.ptr")}
+	} else if size <= b.targetData.TypeAllocSize(b.i8ptrType) {
+		// Packed data stored directly in pointer.
+		if len(valueTypes) == 1 && valueTypes[0].TypeKind() == llvm.IntegerTypeKind {
+			// Keep this cast in SSA form.
+			return []llvm.Value{b.CreatePtrToInt(ptr, valueTypes[0], "unpack.int")}
+		}
+		// Fallback: load it using an alloca.
+		packedRawAlloc, _, _ = b.createTemporaryAlloca(llvm.PointerType(b.i8ptrType, 0), "unpack.raw.alloc")
+		packedRawValue := b.CreateBitCast(ptr, llvm.PointerType(b.i8ptrType, 0), "unpack.raw.value")
+		b.CreateStore(packedRawValue, packedRawAlloc)
+		packedAlloc = b.CreateBitCast(packedRawAlloc, llvm.PointerType(packedType, 0), "unpack.alloc")
+	} else {
+		// Packed data stored on the heap. Bitcast the passed-in pointer to the
+		// correct pointer type.
+		packedAlloc = b.CreateBitCast(ptr, llvm.PointerType(packedType, 0), "unpack.raw.ptr")
+	}
+	// Load each value from the packed data.
+	values := make([]llvm.Value, len(valueTypes))
+	for i, valueType := range valueTypes {
+		if b.targetData.TypeAllocSize(valueType) == 0 {
+			// This value has length zero, so there's nothing to load.
+			values[i] = llvm.ConstNull(valueType)
+			continue
+		}
+		indices := []llvm.Value{
+			llvm.ConstInt(b.ctx.Int32Type(), 0, false),
+			llvm.ConstInt(b.ctx.Int32Type(), uint64(i), false),
+		}
+		gep := b.CreateInBoundsGEP(packedType, packedAlloc, indices, "")
+		values[i] = b.CreateLoad(valueType, gep, "")
+	}
+	if !packedRawAlloc.IsNil() {
+		allocPtr := b.CreateBitCast(packedRawAlloc, b.i8ptrType, "")
+		allocSize := llvm.ConstInt(b.ctx.Int64Type(), b.targetData.TypeAllocSize(b.uintptrType), false)
+		b.emitLifetimeEnd(allocPtr, allocSize)
+	}
+	return values
 }
 
 // makeGlobalArray creates a new LLVM global with the given name and integers as
-// contents, and returns the global.
+// contents, and returns the global and initializer type.
 // Note that it is left with the default linkage etc., you should set
 // linkage/constant/etc properties yourself.
-func (c *compilerContext) makeGlobalArray(buf []byte, name string, elementType llvm.Type) llvm.Value {
+func (c *compilerContext) makeGlobalArray(buf []byte, name string, elementType llvm.Type) (llvm.Type, llvm.Value) {
 	globalType := llvm.ArrayType(elementType, len(buf))
 	global := llvm.AddGlobal(c.mod, globalType, name)
 	value := llvm.Undef(globalType)
 	for i := 0; i < len(buf); i++ {
 		ch := uint64(buf[i])
-		value = llvm.ConstInsertValue(value, llvm.ConstInt(elementType, ch, false), []uint32{uint32(i)})
+		value = c.builder.CreateInsertValue(value, llvm.ConstInt(elementType, ch, false), i, "")
 	}
 	global.SetInitializer(value)
-	return global
+	return globalType, global
 }
 
 // createObjectLayout returns a LLVM value (of type i8*) that describes where
@@ -84,6 +230,8 @@ func (c *compilerContext) makeGlobalArray(buf []byte, name string, elementType l
 // which words contain a pointer (indicated by setting the given bit to 1). For
 // arrays, only the element is stored. This works because the GC knows the
 // object size and can therefore know how this value is repeated in the object.
+//
+// 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 {
 	// Use the element type for arrays. This works even for nested arrays.
 	for {
@@ -166,6 +314,7 @@ func (c *compilerContext) createObjectLayout(t llvm.Type, pos token.Pos) llvm.Va
 	// Create the global initializer.
 	bitmapBytes := make([]byte, int(objectSizeWords+7)/8)
 	bitmap.FillBytes(bitmapBytes)
+	reverseBytes(bitmapBytes) // big-endian to little-endian
 	var bitmapByteValues []llvm.Value
 	for _, b := range bitmapBytes {
 		bitmapByteValues = append(bitmapByteValues, llvm.ConstInt(c.ctx.Int8Type(), uint64(b), false))
@@ -312,5 +461,14 @@ func (b *builder) readStackPointer() llvm.Value {
 		fnType := llvm.FunctionType(b.i8ptrType, nil, false)
 		stacksave = llvm.AddFunction(b.mod, "llvm.stacksave", fnType)
 	}
-	return b.CreateCall(stacksave, nil, "")
+	return b.CreateCall(stacksave.GlobalValueType(), stacksave, nil, "")
+}
+
+// Reverse a slice of bytes. From the wiki:
+// https://github.com/golang/go/wiki/SliceTricks#reversing
+func reverseBytes(buf []byte) {
+	for i := len(buf)/2 - 1; i >= 0; i-- {
+		opp := len(buf) - 1 - i
+		buf[i], buf[opp] = buf[opp], buf[i]
+	}
 }

compiler/llvmutil/llvm.go

@@ -7,7 +7,22 @@
 // places would be a big risk if only one of them is updated.
 package llvmutil
 
-import "tinygo.org/x/go-llvm"
+import (
+	"strconv"
+	"strings"
+
+	"tinygo.org/x/go-llvm"
+)
+
+// Major returns the LLVM major version.
+func Major() int {
+	llvmMajor, err := strconv.Atoi(strings.SplitN(llvm.Version, ".", 2)[0])
+	if err != nil {
+		// sanity check, should be unreachable
+		panic("could not parse LLVM version: " + err.Error())
+	}
+	return llvmMajor
+}
 
 // CreateEntryBlockAlloca creates a new alloca in the entry block, even though
 // the IR builder is located elsewhere. It assumes that the insert point is
@@ -39,7 +54,8 @@ func CreateTemporaryAlloca(builder llvm.Builder, mod llvm.Module, t llvm.Type, n
 	alloca = CreateEntryBlockAlloca(builder, t, name)
 	bitcast = builder.CreateBitCast(alloca, i8ptrType, name+".bitcast")
 	size = llvm.ConstInt(ctx.Int64Type(), targetData.TypeAllocSize(t), false)
-	builder.CreateCall(getLifetimeStartFunc(mod), []llvm.Value{size, bitcast}, "")
+	fnType, fn := getLifetimeStartFunc(mod)
+	builder.CreateCall(fnType, fn, []llvm.Value{size, bitcast}, "")
 	return
 }
 
@@ -54,13 +70,15 @@ func CreateInstructionAlloca(builder llvm.Builder, mod llvm.Module, t llvm.Type,
 	builder.SetInsertPointBefore(inst)
 	bitcast := builder.CreateBitCast(alloca, i8ptrType, name+".bitcast")
 	size := llvm.ConstInt(ctx.Int64Type(), targetData.TypeAllocSize(t), false)
-	builder.CreateCall(getLifetimeStartFunc(mod), []llvm.Value{size, bitcast}, "")
+	fnType, fn := getLifetimeStartFunc(mod)
+	builder.CreateCall(fnType, fn, []llvm.Value{size, bitcast}, "")
 	if next := llvm.NextInstruction(inst); !next.IsNil() {
 		builder.SetInsertPointBefore(next)
 	} else {
 		builder.SetInsertPointAtEnd(inst.InstructionParent())
 	}
-	builder.CreateCall(getLifetimeEndFunc(mod), []llvm.Value{size, bitcast}, "")
+	fnType, fn = getLifetimeEndFunc(mod)
+	builder.CreateCall(fnType, fn, []llvm.Value{size, bitcast}, "")
 	return alloca
 }
 
@@ -68,33 +86,42 @@ func CreateInstructionAlloca(builder llvm.Builder, mod llvm.Module, t llvm.Type,
 // llvm.lifetime.end intrinsic. It is commonly used together with
 // createTemporaryAlloca.
 func EmitLifetimeEnd(builder llvm.Builder, mod llvm.Module, ptr, size llvm.Value) {
-	builder.CreateCall(getLifetimeEndFunc(mod), []llvm.Value{size, ptr}, "")
+	fnType, fn := getLifetimeEndFunc(mod)
+	builder.CreateCall(fnType, fn, []llvm.Value{size, ptr}, "")
 }
 
 // getLifetimeStartFunc returns the llvm.lifetime.start intrinsic and creates it
 // first if it doesn't exist yet.
-func getLifetimeStartFunc(mod llvm.Module) llvm.Value {
+func getLifetimeStartFunc(mod llvm.Module) (llvm.Type, llvm.Value) {
-	fn := mod.NamedFunction("llvm.lifetime.start.p0i8")
+	fnName := "llvm.lifetime.start.p0"
+	if Major() < 15 { // compatibility with LLVM 14
+		fnName = "llvm.lifetime.start.p0i8"
+	}
+	fn := mod.NamedFunction(fnName)
 	ctx := mod.Context()
 	i8ptrType := llvm.PointerType(ctx.Int8Type(), 0)
+	fnType := llvm.FunctionType(ctx.VoidType(), []llvm.Type{ctx.Int64Type(), i8ptrType}, false)
 	if fn.IsNil() {
-		fnType := llvm.FunctionType(ctx.VoidType(), []llvm.Type{ctx.Int64Type(), i8ptrType}, false)
+		fn = llvm.AddFunction(mod, fnName, fnType)
-		fn = llvm.AddFunction(mod, "llvm.lifetime.start.p0i8", fnType)
 	}
-	return fn
+	return fnType, fn
 }
 
 // getLifetimeEndFunc returns the llvm.lifetime.end intrinsic and creates it
 // first if it doesn't exist yet.
-func getLifetimeEndFunc(mod llvm.Module) llvm.Value {
+func getLifetimeEndFunc(mod llvm.Module) (llvm.Type, llvm.Value) {
-	fn := mod.NamedFunction("llvm.lifetime.end.p0i8")
+	fnName := "llvm.lifetime.end.p0"
+	if Major() < 15 {
+		fnName = "llvm.lifetime.end.p0i8"
+	}
+	fn := mod.NamedFunction(fnName)
 	ctx := mod.Context()
 	i8ptrType := llvm.PointerType(ctx.Int8Type(), 0)
+	fnType := llvm.FunctionType(ctx.VoidType(), []llvm.Type{ctx.Int64Type(), i8ptrType}, false)
 	if fn.IsNil() {
-		fnType := llvm.FunctionType(ctx.VoidType(), []llvm.Type{ctx.Int64Type(), i8ptrType}, false)
+		fn = llvm.AddFunction(mod, fnName, fnType)
-		fn = llvm.AddFunction(mod, "llvm.lifetime.end.p0i8", fnType)
 	}
-	return fn
+	return fnType, fn
 }
 
 // SplitBasicBlock splits a LLVM basic block into two parts. All instructions
@@ -168,3 +195,32 @@ func SplitBasicBlock(builder llvm.Builder, afterInst llvm.Value, insertAfter llv
 
 	return newBlock
 }
+
+// Append the given values to a global array like llvm.used. The global might
+// not exist yet. The values can be any pointer type, they will be cast to i8*.
+func AppendToGlobal(mod llvm.Module, globalName string, values ...llvm.Value) {
+	// Read the existing values in the llvm.used array (if it exists).
+	var usedValues []llvm.Value
+	if used := mod.NamedGlobal(globalName); !used.IsNil() {
+		builder := mod.Context().NewBuilder()
+		defer builder.Dispose()
+		usedInitializer := used.Initializer()
+		num := usedInitializer.Type().ArrayLength()
+		for i := 0; i < num; i++ {
+			usedValues = append(usedValues, builder.CreateExtractValue(usedInitializer, i, ""))
+		}
+		used.EraseFromParentAsGlobal()
+	}
+
+	// Add the new values.
+	i8ptrType := llvm.PointerType(mod.Context().Int8Type(), 0)
+	for _, value := range values {
+		usedValues = append(usedValues, llvm.ConstPointerCast(value, i8ptrType))
+	}
+
+	// Create a new array (with the old and new values).
+	usedInitializer := llvm.ConstArray(i8ptrType, usedValues)
+	used := llvm.AddGlobal(mod, usedInitializer.Type(), globalName)
+	used.SetInitializer(usedInitializer)
+	used.SetLinkage(llvm.AppendingLinkage)
+}

compiler/llvmutil/wordpack.go

@@ -1,182 +0,0 @@
-package llvmutil
-
-// This file contains utility functions to pack and unpack sets of values. It
-// can take in a list of values and tries to store it efficiently in the pointer
-// itself if possible and legal.
-
-import (
-	"tinygo.org/x/go-llvm"
-)
-
-// EmitPointerPack packs the list of values into a single pointer value using
-// bitcasts, or else allocates a value on the heap if it cannot be packed in the
-// 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 EmitPointerPack(builder llvm.Builder, mod llvm.Module, prefix string, needsStackObjects bool, values []llvm.Value) llvm.Value {
-	ctx := mod.Context()
-	targetData := llvm.NewTargetData(mod.DataLayout())
-	defer targetData.Dispose()
-	i8ptrType := llvm.PointerType(mod.Context().Int8Type(), 0)
-	uintptrType := ctx.IntType(targetData.PointerSize() * 8)
-
-	valueTypes := make([]llvm.Type, len(values))
-	for i, value := range values {
-		valueTypes[i] = value.Type()
-	}
-	packedType := ctx.StructType(valueTypes, false)
-
-	// Allocate memory for the packed data.
-	size := targetData.TypeAllocSize(packedType)
-	if size == 0 {
-		return llvm.ConstPointerNull(i8ptrType)
-	} else if len(values) == 1 && values[0].Type().TypeKind() == llvm.PointerTypeKind {
-		return builder.CreateBitCast(values[0], i8ptrType, "pack.ptr")
-	} else if size <= targetData.TypeAllocSize(i8ptrType) {
-		// Packed data fits in a pointer, so store it directly inside the
-		// pointer.
-		if len(values) == 1 && values[0].Type().TypeKind() == llvm.IntegerTypeKind {
-			// Try to keep this cast in SSA form.
-			return builder.CreateIntToPtr(values[0], i8ptrType, "pack.int")
-		}
-
-		// Because packedType is a struct and we have to cast it to a *i8, store
-		// it in a *i8 alloca first and load the *i8 value from there. This is
-		// effectively a bitcast.
-		packedAlloc, _, _ := CreateTemporaryAlloca(builder, mod, i8ptrType, "")
-
-		if size < targetData.TypeAllocSize(i8ptrType) {
-			// The alloca is bigger than the value that will be stored in it.
-			// To avoid having some bits undefined, zero the alloca first.
-			// Hopefully this will get optimized away.
-			builder.CreateStore(llvm.ConstNull(i8ptrType), packedAlloc)
-		}
-
-		// Store all values in the alloca.
-		packedAllocCast := builder.CreateBitCast(packedAlloc, llvm.PointerType(packedType, 0), "")
-		for i, value := range values {
-			indices := []llvm.Value{
-				llvm.ConstInt(ctx.Int32Type(), 0, false),
-				llvm.ConstInt(ctx.Int32Type(), uint64(i), false),
-			}
-			gep := builder.CreateInBoundsGEP(packedAllocCast, indices, "")
-			builder.CreateStore(value, gep)
-		}
-
-		// Load value (the *i8) from the alloca.
-		result := builder.CreateLoad(packedAlloc, "")
-
-		// End the lifetime of the alloca, to help the optimizer.
-		packedPtr := builder.CreateBitCast(packedAlloc, i8ptrType, "")
-		packedSize := llvm.ConstInt(ctx.Int64Type(), targetData.TypeAllocSize(packedAlloc.Type()), false)
-		EmitLifetimeEnd(builder, mod, packedPtr, packedSize)
-
-		return result
-	} else {
-		// Check if the values are all constants.
-		constant := true
-		for _, v := range values {
-			if !v.IsConstant() {
-				constant = false
-				break
-			}
-		}
-
-		if constant {
-			// The data is known at compile time, so store it in a constant global.
-			// The global address is marked as unnamed, which allows LLVM to merge duplicates.
-			global := llvm.AddGlobal(mod, packedType, prefix+"$pack")
-			global.SetInitializer(ctx.ConstStruct(values, false))
-			global.SetGlobalConstant(true)
-			global.SetUnnamedAddr(true)
-			global.SetLinkage(llvm.InternalLinkage)
-			return llvm.ConstBitCast(global, i8ptrType)
-		}
-
-		// Packed data is bigger than a pointer, so allocate it on the heap.
-		sizeValue := llvm.ConstInt(uintptrType, size, false)
-		alloc := mod.NamedFunction("runtime.alloc")
-		packedHeapAlloc := builder.CreateCall(alloc, []llvm.Value{
-			sizeValue,
-			llvm.ConstNull(i8ptrType),
-			llvm.Undef(i8ptrType), // unused context parameter
-		}, "")
-		if needsStackObjects {
-			trackPointer := mod.NamedFunction("runtime.trackPointer")
-			builder.CreateCall(trackPointer, []llvm.Value{
-				packedHeapAlloc,
-				llvm.Undef(i8ptrType), // unused context parameter
-			}, "")
-		}
-		packedAlloc := builder.CreateBitCast(packedHeapAlloc, llvm.PointerType(packedType, 0), "")
-
-		// Store all values in the heap pointer.
-		for i, value := range values {
-			indices := []llvm.Value{
-				llvm.ConstInt(ctx.Int32Type(), 0, false),
-				llvm.ConstInt(ctx.Int32Type(), uint64(i), false),
-			}
-			gep := builder.CreateInBoundsGEP(packedAlloc, indices, "")
-			builder.CreateStore(value, gep)
-		}
-
-		// Return the original heap allocation pointer, which already is an *i8.
-		return packedHeapAlloc
-	}
-}
-
-// EmitPointerUnpack extracts a list of values packed using EmitPointerPack.
-func EmitPointerUnpack(builder llvm.Builder, mod llvm.Module, ptr llvm.Value, valueTypes []llvm.Type) []llvm.Value {
-	ctx := mod.Context()
-	targetData := llvm.NewTargetData(mod.DataLayout())
-	defer targetData.Dispose()
-	i8ptrType := llvm.PointerType(mod.Context().Int8Type(), 0)
-	uintptrType := ctx.IntType(targetData.PointerSize() * 8)
-
-	packedType := ctx.StructType(valueTypes, false)
-
-	// Get a correctly-typed pointer to the packed data.
-	var packedAlloc, packedRawAlloc llvm.Value
-	size := targetData.TypeAllocSize(packedType)
-	if size == 0 {
-		// No data to unpack.
-	} else if len(valueTypes) == 1 && valueTypes[0].TypeKind() == llvm.PointerTypeKind {
-		// A single pointer is always stored directly.
-		return []llvm.Value{builder.CreateBitCast(ptr, valueTypes[0], "unpack.ptr")}
-	} else if size <= targetData.TypeAllocSize(i8ptrType) {
-		// Packed data stored directly in pointer.
-		if len(valueTypes) == 1 && valueTypes[0].TypeKind() == llvm.IntegerTypeKind {
-			// Keep this cast in SSA form.
-			return []llvm.Value{builder.CreatePtrToInt(ptr, valueTypes[0], "unpack.int")}
-		}
-		// Fallback: load it using an alloca.
-		packedRawAlloc, _, _ = CreateTemporaryAlloca(builder, mod, llvm.PointerType(i8ptrType, 0), "unpack.raw.alloc")
-		packedRawValue := builder.CreateBitCast(ptr, llvm.PointerType(i8ptrType, 0), "unpack.raw.value")
-		builder.CreateStore(packedRawValue, packedRawAlloc)
-		packedAlloc = builder.CreateBitCast(packedRawAlloc, llvm.PointerType(packedType, 0), "unpack.alloc")
-	} else {
-		// Packed data stored on the heap. Bitcast the passed-in pointer to the
-		// correct pointer type.
-		packedAlloc = builder.CreateBitCast(ptr, llvm.PointerType(packedType, 0), "unpack.raw.ptr")
-	}
-	// Load each value from the packed data.
-	values := make([]llvm.Value, len(valueTypes))
-	for i, valueType := range valueTypes {
-		if targetData.TypeAllocSize(valueType) == 0 {
-			// This value has length zero, so there's nothing to load.
-			values[i] = llvm.ConstNull(valueType)
-			continue
-		}
-		indices := []llvm.Value{
-			llvm.ConstInt(ctx.Int32Type(), 0, false),
-			llvm.ConstInt(ctx.Int32Type(), uint64(i), false),
-		}
-		gep := builder.CreateInBoundsGEP(packedAlloc, indices, "")
-		values[i] = builder.CreateLoad(gep, "")
-	}
-	if !packedRawAlloc.IsNil() {
-		allocPtr := builder.CreateBitCast(packedRawAlloc, i8ptrType, "")
-		allocSize := llvm.ConstInt(ctx.Int64Type(), targetData.TypeAllocSize(uintptrType), false)
-		EmitLifetimeEnd(builder, mod, allocPtr, allocSize)
-	}
-	return values
-}

compiler/map.go

@@ -41,8 +41,8 @@ func (b *builder) createMakeMap(expr *ssa.MakeMap) (llvm.Value, error) {
 	}
 	keySize := b.targetData.TypeAllocSize(llvmKeyType)
 	valueSize := b.targetData.TypeAllocSize(llvmValueType)
-	llvmKeySize := llvm.ConstInt(b.ctx.Int8Type(), keySize, false)
+	llvmKeySize := llvm.ConstInt(b.uintptrType, keySize, false)
-	llvmValueSize := llvm.ConstInt(b.ctx.Int8Type(), valueSize, 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 {
@@ -106,7 +106,7 @@ func (b *builder) createMapLookup(keyType, valueType types.Type, m, key llvm.Val
 
 	// 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(mapValueAlloca, "")
+	mapValue := b.CreateLoad(llvmValueType, mapValueAlloca, "")
 	b.emitLifetimeEnd(mapValuePtr, mapValueAllocaSize)
 
 	if commaOk {
@@ -217,8 +217,8 @@ func (b *builder) createMapIteratorNext(rangeVal ssa.Value, llvmRangeVal, it llv
 	mapKeyAlloca, mapKeyPtr, mapKeySize := b.createTemporaryAlloca(llvmStoredKeyType, "range.key")
 	mapValueAlloca, mapValuePtr, mapValueSize := b.createTemporaryAlloca(llvmValueType, "range.value")
 	ok := b.createRuntimeCall("hashmapNext", []llvm.Value{llvmRangeVal, it, mapKeyPtr, mapValuePtr}, "range.next")
-	mapKey := b.CreateLoad(mapKeyAlloca, "")
+	mapKey := b.CreateLoad(llvmStoredKeyType, mapKeyAlloca, "")
-	mapValue := b.CreateLoad(mapValueAlloca, "")
+	mapValue := b.CreateLoad(llvmValueType, mapValueAlloca, "")
 
 	if isKeyStoredAsInterface {
 		// The key is stored as an interface but it isn't of interface type.

compiler/symbol.go

@@ -10,6 +10,7 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/tinygo-org/tinygo/compiler/llvmutil"
 	"github.com/tinygo-org/tinygo/loader"
 	"golang.org/x/tools/go/ssa"
 	"tinygo.org/x/go-llvm"
@@ -53,11 +54,11 @@ const (
 
 // getFunction returns the LLVM function for the given *ssa.Function, creating
 // it if needed. It can later be filled with compilerContext.createFunction().
-func (c *compilerContext) getFunction(fn *ssa.Function) llvm.Value {
+func (c *compilerContext) getFunction(fn *ssa.Function) (llvm.Type, llvm.Value) {
 	info := c.getFunctionInfo(fn)
 	llvmFn := c.mod.NamedFunction(info.linkName)
 	if !llvmFn.IsNil() {
-		return llvmFn
+		return llvmFn.GlobalValueType(), llvmFn
 	}
 
 	var retType llvm.Type
@@ -83,7 +84,7 @@ func (c *compilerContext) getFunction(fn *ssa.Function) llvm.Value {
 	// Add an extra parameter as the function context. This context is used in
 	// closures and bound methods, but should be optimized away when not used.
 	if !info.exported {
-		paramInfos = append(paramInfos, paramInfo{llvmType: c.i8ptrType, name: "context", flags: 0})
+		paramInfos = append(paramInfos, paramInfo{llvmType: c.i8ptrType, name: "context", elemSize: 0})
 	}
 
 	var paramTypes []llvm.Type
@@ -112,17 +113,8 @@ func (c *compilerContext) getFunction(fn *ssa.Function) llvm.Value {
 
 	dereferenceableOrNullKind := llvm.AttributeKindID("dereferenceable_or_null")
 	for i, info := range paramInfos {
-		if info.flags&paramIsDeferenceableOrNull == 0 {
+		if info.elemSize != 0 {
-			continue
+			dereferenceableOrNull := c.ctx.CreateEnumAttribute(dereferenceableOrNullKind, info.elemSize)
-		}
-		if info.llvmType.TypeKind() == llvm.PointerTypeKind {
-			el := info.llvmType.ElementType()
-			size := c.targetData.TypeAllocSize(el)
-			if size == 0 {
-				// dereferenceable_or_null(0) appears to be illegal in LLVM.
-				continue
-			}
-			dereferenceableOrNull := c.ctx.CreateEnumAttribute(dereferenceableOrNullKind, size)
 			llvmFn.AddAttributeAtIndex(i+1, dereferenceableOrNull)
 		}
 	}
@@ -158,6 +150,19 @@ func (c *compilerContext) getFunction(fn *ssa.Function) llvm.Value {
 		// that the only thing we'll do is read the pointer.
 		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" {
+			// These functions are compiler-rt/libgcc functions that are
+			// currently implemented in Go. Assembly versions should appear in
+			// LLVM 16 hopefully. Until then, they need to be made available to
+			// the linker and the best way to do that is llvm.compiler.used.
+			// I considered adding a pragma for this, but the LLVM language
+			// reference explicitly says that this feature should not be exposed
+			// to source languages:
+			// > This is a rare construct that should only be used in rare
+			// > circumstances, and should not be exposed to source languages.
+			llvmutil.AppendToGlobal(c.mod, "llvm.compiler.used", llvmFn)
+		}
 	}
 
 	// External/exported functions may not retain pointer values.
@@ -202,7 +207,7 @@ func (c *compilerContext) getFunction(fn *ssa.Function) llvm.Value {
 		llvmFn.SetUnnamedAddr(true)
 	}
 
-	return llvmFn
+	return fnType, llvmFn
 }
 
 // getFunctionInfo returns information about a function that is not directly
@@ -362,7 +367,15 @@ func (c *compilerContext) addStandardDefinedAttributes(llvmFn llvm.Value) {
 	llvmFn.AddFunctionAttr(c.ctx.CreateEnumAttribute(llvm.AttributeKindID("nounwind"), 0))
 	if strings.Split(c.Triple, "-")[0] == "x86_64" {
 		// Required by the ABI.
-		llvmFn.AddFunctionAttr(c.ctx.CreateEnumAttribute(llvm.AttributeKindID("uwtable"), 0))
+		if llvmutil.Major() < 15 {
+			// Needed for LLVM 14 support.
+			llvmFn.AddFunctionAttr(c.ctx.CreateEnumAttribute(llvm.AttributeKindID("uwtable"), 0))
+		} else {
+			// The uwtable has two possible values: sync (1) or async (2). We
+			// use sync because we currently don't use async unwind tables.
+			// For details, see: https://llvm.org/docs/LangRef.html#function-attributes
+			llvmFn.AddFunctionAttr(c.ctx.CreateEnumAttribute(llvm.AttributeKindID("uwtable"), 1))
+		}
 	}
 }
 

compiler/syscall.go

@@ -44,7 +44,7 @@ func (b *builder) createRawSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		constraints += ",~{rcx},~{r11}"
 		fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
 		target := llvm.InlineAsm(fnType, "syscall", constraints, true, false, llvm.InlineAsmDialectIntel, false)
-		return b.CreateCall(target, args, ""), nil
+		return b.CreateCall(fnType, target, args, ""), nil
 	case b.GOARCH == "386" && b.GOOS == "linux":
 		// Sources:
 		//   syscall(2) man page
@@ -70,7 +70,7 @@ func (b *builder) createRawSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		}
 		fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
 		target := llvm.InlineAsm(fnType, "int 0x80", constraints, true, false, llvm.InlineAsmDialectIntel, false)
-		return b.CreateCall(target, args, ""), nil
+		return b.CreateCall(fnType, target, args, ""), nil
 	case b.GOARCH == "arm" && b.GOOS == "linux":
 		// Implement the EABI system call convention for Linux.
 		// Source: syscall(2) man page.
@@ -102,7 +102,7 @@ func (b *builder) createRawSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		}
 		fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
 		target := llvm.InlineAsm(fnType, "svc #0", constraints, true, false, 0, false)
-		return b.CreateCall(target, args, ""), nil
+		return b.CreateCall(fnType, target, args, ""), nil
 	case b.GOARCH == "arm64" && b.GOOS == "linux":
 		// Source: syscall(2) man page.
 		args := []llvm.Value{}
@@ -134,7 +134,7 @@ func (b *builder) createRawSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		constraints += ",~{x16},~{x17}" // scratch registers
 		fnType := llvm.FunctionType(b.uintptrType, argTypes, false)
 		target := llvm.InlineAsm(fnType, "svc #0", constraints, true, false, 0, false)
-		return b.CreateCall(target, args, ""), nil
+		return b.CreateCall(fnType, target, args, ""), nil
 	default:
 		return llvm.Value{}, b.makeError(call.Pos(), "unknown GOOS/GOARCH for syscall: "+b.GOOS+"/"+b.GOARCH)
 	}
@@ -205,9 +205,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.
-		b.CreateCall(setLastError, []llvm.Value{llvm.ConstNull(b.ctx.Int32Type())}, "")
+		b.CreateCall(setLastError.GlobalValueType(), setLastError, []llvm.Value{llvm.ConstNull(b.ctx.Int32Type())}, "")
-		syscallResult := b.CreateCall(fnPtr, params, "")
+		syscallResult := b.CreateCall(llvmType, fnPtr, params, "")
-		errResult := b.CreateCall(getLastError, nil, "err")
+		errResult := b.CreateCall(getLastError.GlobalValueType(), getLastError, nil, "err")
 		if b.uintptrType != b.ctx.Int32Type() {
 			errResult = b.CreateZExt(errResult, b.uintptrType, "err.uintptr")
 		}

compiler/testdata/basic.go

@@ -75,14 +75,24 @@ func complexMul(x, y complex64) complex64 {
 // A type 'kv' also exists in function foo. Test that these two types don't
 // conflict with each other.
 type kv struct {
-	v float32
+	v       float32
+	x, y, z int
 }
 
-func foo(a *kv) {
+var kvGlobal kv
+
+func foo() {
 	// Define a new 'kv' type.
 	type kv struct {
-		v byte
+		v       byte
+		x, y, z int
 	}
 	// Use this type.
-	func(b *kv) {}(nil)
+	func(b kv) {}(kv{})
 }
+
+type T1 []T1
+type T2 [2]*T2
+
+var a T1
+var b T2

compiler/testdata/basic.ll

@@ -3,35 +3,39 @@ source_filename = "basic.go"
 target datalayout = "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-n32:64-S128-ni:1:10:20"
 target triple = "wasm32-unknown-wasi"
 
-%main.kv = type { float }
+%main.kv = type { float, i32, i32, i32 }
-%main.kv.0 = type { i8 }
+%main.kv.0 = type { i8, i32, i32, i32 }
 
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*) #0
+@main.kvGlobal = hidden global %main.kv zeroinitializer, align 4
+@main.a = hidden global { ptr, i32, i32 } zeroinitializer, align 4
+@main.b = hidden global [2 x ptr] zeroinitializer, align 4
 
-declare void @runtime.trackPointer(i8* nocapture readonly, i8*) #0
+declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #0
+
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.init(i8* %context) unnamed_addr #1 {
+define hidden void @main.init(ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.addInt(i32 %x, i32 %y, i8* %context) unnamed_addr #1 {
+define hidden i32 @main.addInt(i32 %x, i32 %y, ptr %context) unnamed_addr #1 {
 entry:
   %0 = add i32 %x, %y
   ret i32 %0
 }
 
 ; Function Attrs: nounwind
-define hidden i1 @main.equalInt(i32 %x, i32 %y, i8* %context) unnamed_addr #1 {
+define hidden i1 @main.equalInt(i32 %x, i32 %y, ptr %context) unnamed_addr #1 {
 entry:
   %0 = icmp eq i32 %x, %y
   ret i1 %0
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.divInt(i32 %x, i32 %y, i8* %context) unnamed_addr #1 {
+define hidden i32 @main.divInt(i32 %x, i32 %y, ptr %context) unnamed_addr #1 {
 entry:
   %0 = icmp eq i32 %y, 0
   br i1 %0, label %divbyzero.throw, label %divbyzero.next
@@ -45,14 +49,14 @@ divbyzero.next:                                   ; preds = %entry
   ret i32 %5
 
 divbyzero.throw:                                  ; preds = %entry
-  call void @runtime.divideByZeroPanic(i8* undef) #2
+  call void @runtime.divideByZeroPanic(ptr undef) #2
   unreachable
 }
 
-declare void @runtime.divideByZeroPanic(i8*) #0
+declare void @runtime.divideByZeroPanic(ptr) #0
 
 ; Function Attrs: nounwind
-define hidden i32 @main.divUint(i32 %x, i32 %y, i8* %context) unnamed_addr #1 {
+define hidden i32 @main.divUint(i32 %x, i32 %y, ptr %context) unnamed_addr #1 {
 entry:
   %0 = icmp eq i32 %y, 0
   br i1 %0, label %divbyzero.throw, label %divbyzero.next
@@ -62,12 +66,12 @@ divbyzero.next:                                   ; preds = %entry
   ret i32 %1
 
 divbyzero.throw:                                  ; preds = %entry
-  call void @runtime.divideByZeroPanic(i8* undef) #2
+  call void @runtime.divideByZeroPanic(ptr undef) #2
   unreachable
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.remInt(i32 %x, i32 %y, i8* %context) unnamed_addr #1 {
+define hidden i32 @main.remInt(i32 %x, i32 %y, ptr %context) unnamed_addr #1 {
 entry:
   %0 = icmp eq i32 %y, 0
   br i1 %0, label %divbyzero.throw, label %divbyzero.next
@@ -81,12 +85,12 @@ divbyzero.next:                                   ; preds = %entry
   ret i32 %5
 
 divbyzero.throw:                                  ; preds = %entry
-  call void @runtime.divideByZeroPanic(i8* undef) #2
+  call void @runtime.divideByZeroPanic(ptr undef) #2
   unreachable
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.remUint(i32 %x, i32 %y, i8* %context) unnamed_addr #1 {
+define hidden i32 @main.remUint(i32 %x, i32 %y, ptr %context) unnamed_addr #1 {
 entry:
   %0 = icmp eq i32 %y, 0
   br i1 %0, label %divbyzero.throw, label %divbyzero.next
@@ -96,66 +100,66 @@ divbyzero.next:                                   ; preds = %entry
   ret i32 %1
 
 divbyzero.throw:                                  ; preds = %entry
-  call void @runtime.divideByZeroPanic(i8* undef) #2
+  call void @runtime.divideByZeroPanic(ptr undef) #2
   unreachable
 }
 
 ; Function Attrs: nounwind
-define hidden i1 @main.floatEQ(float %x, float %y, i8* %context) unnamed_addr #1 {
+define hidden i1 @main.floatEQ(float %x, float %y, ptr %context) unnamed_addr #1 {
 entry:
   %0 = fcmp oeq float %x, %y
   ret i1 %0
 }
 
 ; Function Attrs: nounwind
-define hidden i1 @main.floatNE(float %x, float %y, i8* %context) unnamed_addr #1 {
+define hidden i1 @main.floatNE(float %x, float %y, ptr %context) unnamed_addr #1 {
 entry:
   %0 = fcmp une float %x, %y
   ret i1 %0
 }
 
 ; Function Attrs: nounwind
-define hidden i1 @main.floatLower(float %x, float %y, i8* %context) unnamed_addr #1 {
+define hidden i1 @main.floatLower(float %x, float %y, ptr %context) unnamed_addr #1 {
 entry:
   %0 = fcmp olt float %x, %y
   ret i1 %0
 }
 
 ; Function Attrs: nounwind
-define hidden i1 @main.floatLowerEqual(float %x, float %y, i8* %context) unnamed_addr #1 {
+define hidden i1 @main.floatLowerEqual(float %x, float %y, ptr %context) unnamed_addr #1 {
 entry:
   %0 = fcmp ole float %x, %y
   ret i1 %0
 }
 
 ; Function Attrs: nounwind
-define hidden i1 @main.floatGreater(float %x, float %y, i8* %context) unnamed_addr #1 {
+define hidden i1 @main.floatGreater(float %x, float %y, ptr %context) unnamed_addr #1 {
 entry:
   %0 = fcmp ogt float %x, %y
   ret i1 %0
 }
 
 ; Function Attrs: nounwind
-define hidden i1 @main.floatGreaterEqual(float %x, float %y, i8* %context) unnamed_addr #1 {
+define hidden i1 @main.floatGreaterEqual(float %x, float %y, ptr %context) unnamed_addr #1 {
 entry:
   %0 = fcmp oge float %x, %y
   ret i1 %0
 }
 
 ; Function Attrs: nounwind
-define hidden float @main.complexReal(float %x.r, float %x.i, i8* %context) unnamed_addr #1 {
+define hidden float @main.complexReal(float %x.r, float %x.i, ptr %context) unnamed_addr #1 {
 entry:
   ret float %x.r
 }
 
 ; Function Attrs: nounwind
-define hidden float @main.complexImag(float %x.r, float %x.i, i8* %context) unnamed_addr #1 {
+define hidden float @main.complexImag(float %x.r, float %x.i, ptr %context) unnamed_addr #1 {
 entry:
   ret float %x.i
 }
 
 ; Function Attrs: nounwind
-define hidden { float, float } @main.complexAdd(float %x.r, float %x.i, float %y.r, float %y.i, i8* %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 #1 {
 entry:
   %0 = fadd float %x.r, %y.r
   %1 = fadd float %x.i, %y.i
@@ -165,7 +169,7 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden { float, float } @main.complexSub(float %x.r, float %x.i, float %y.r, float %y.i, i8* %context) unnamed_addr #1 {
+define hidden { float, float } @main.complexSub(float %x.r, float %x.i, float %y.r, float %y.i, ptr %context) unnamed_addr #1 {
 entry:
   %0 = fsub float %x.r, %y.r
   %1 = fsub float %x.i, %y.i
@@ -175,7 +179,7 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden { float, float } @main.complexMul(float %x.r, float %x.i, float %y.r, float %y.i, i8* %context) unnamed_addr #1 {
+define hidden { float, float } @main.complexMul(float %x.r, float %x.i, float %y.r, float %y.i, ptr %context) unnamed_addr #1 {
 entry:
   %0 = fmul float %x.r, %y.r
   %1 = fmul float %x.i, %y.i
@@ -189,15 +193,24 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.foo(%main.kv* dereferenceable_or_null(4) %a, i8* %context) unnamed_addr #1 {
+define hidden void @main.foo(ptr %context) unnamed_addr #1 {
 entry:
-  call void @"main.foo$1"(%main.kv.0* null, i8* undef)
+  %complit = alloca %main.kv.0, align 8
+  %stackalloc = alloca i8, align 1
+  store %main.kv.0 zeroinitializer, ptr %complit, align 8
+  call void @runtime.trackPointer(ptr nonnull %complit, ptr nonnull %stackalloc, ptr undef) #2
+  call void @"main.foo$1"(%main.kv.0 zeroinitializer, ptr undef)
   ret void
 }
 
 ; Function Attrs: nounwind
-define internal void @"main.foo$1"(%main.kv.0* dereferenceable_or_null(1) %b, i8* %context) unnamed_addr #1 {
+define internal void @"main.foo$1"(%main.kv.0 %b, ptr %context) unnamed_addr #1 {
 entry:
+  %b1 = alloca %main.kv.0, align 8
+  %stackalloc = alloca i8, align 1
+  store %main.kv.0 zeroinitializer, ptr %b1, align 8
+  call void @runtime.trackPointer(ptr nonnull %b1, ptr nonnull %stackalloc, ptr undef) #2
+  store %main.kv.0 %b, ptr %b1, align 8
   ret void
 }
 

compiler/testdata/channel.ll

@@ -3,110 +3,95 @@ source_filename = "channel.go"
 target datalayout = "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-n32:64-S128-ni:1:10:20"
 target triple = "wasm32-unknown-wasi"
 
-%runtime.channel = type { i32, i32, i8, %runtime.channelBlockedList*, i32, i32, i32, i8* }
+%runtime.channelBlockedList = type { ptr, ptr, ptr, { ptr, i32, i32 } }
-%runtime.channelBlockedList = type { %runtime.channelBlockedList*, %"internal/task.Task"*, %runtime.chanSelectState*, { %runtime.channelBlockedList*, i32, i32 } }
+%runtime.chanSelectState = type { ptr, ptr }
-%"internal/task.Task" = type { %"internal/task.Task"*, i8*, i64, %"internal/task.gcData", %"internal/task.state", i8* }
-%"internal/task.gcData" = type { i8* }
-%"internal/task.state" = type { i32, i8*, %"internal/task.stackState", i1 }
-%"internal/task.stackState" = type { i32, i32 }
-%runtime.chanSelectState = type { %runtime.channel*, i8* }
 
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*) #0
+declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #0
 
-declare void @runtime.trackPointer(i8* nocapture readonly, i8*) #0
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.init(i8* %context) unnamed_addr #1 {
+define hidden void @main.init(ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.chanIntSend(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context) unnamed_addr #1 {
+define hidden void @main.chanIntSend(ptr dereferenceable_or_null(32) %ch, ptr %context) unnamed_addr #1 {
 entry:
   %chan.blockedList = alloca %runtime.channelBlockedList, align 8
   %chan.value = alloca i32, align 4
-  %chan.value.bitcast = bitcast i32* %chan.value to i8*
+  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %chan.value)
-  call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull %chan.value.bitcast)
+  store i32 3, ptr %chan.value, align 4
-  store i32 3, i32* %chan.value, align 4
+  call void @llvm.lifetime.start.p0(i64 24, ptr nonnull %chan.blockedList)
-  %chan.blockedList.bitcast = bitcast %runtime.channelBlockedList* %chan.blockedList to i8*
+  call void @runtime.chanSend(ptr %ch, ptr nonnull %chan.value, ptr nonnull %chan.blockedList, ptr undef) #3
-  call void @llvm.lifetime.start.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
+  call void @llvm.lifetime.end.p0(i64 24, ptr nonnull %chan.blockedList)
-  call void @runtime.chanSend(%runtime.channel* %ch, i8* nonnull %chan.value.bitcast, %runtime.channelBlockedList* nonnull %chan.blockedList, i8* undef) #3
+  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %chan.value)
-  call void @llvm.lifetime.end.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
-  call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull %chan.value.bitcast)
   ret void
 }
 
-; Function Attrs: argmemonly nofree nosync nounwind willreturn
+; Function Attrs: argmemonly nocallback nofree nosync nounwind willreturn
-declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture) #2
+declare void @llvm.lifetime.start.p0(i64 immarg, ptr nocapture) #2
 
-declare void @runtime.chanSend(%runtime.channel* dereferenceable_or_null(32), i8*, %runtime.channelBlockedList* dereferenceable_or_null(24), i8*) #0
+declare void @runtime.chanSend(ptr dereferenceable_or_null(32), ptr, ptr dereferenceable_or_null(24), ptr) #0
 
-; Function Attrs: argmemonly nofree nosync nounwind willreturn
+; Function Attrs: argmemonly nocallback nofree nosync nounwind willreturn
-declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture) #2
+declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #2
 
 ; Function Attrs: nounwind
-define hidden void @main.chanIntRecv(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context) unnamed_addr #1 {
+define hidden void @main.chanIntRecv(ptr dereferenceable_or_null(32) %ch, ptr %context) unnamed_addr #1 {
 entry:
   %chan.blockedList = alloca %runtime.channelBlockedList, align 8
   %chan.value = alloca i32, align 4
-  %chan.value.bitcast = bitcast i32* %chan.value to i8*
+  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %chan.value)
-  call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull %chan.value.bitcast)
+  call void @llvm.lifetime.start.p0(i64 24, ptr nonnull %chan.blockedList)
-  %chan.blockedList.bitcast = bitcast %runtime.channelBlockedList* %chan.blockedList to i8*
+  %0 = call i1 @runtime.chanRecv(ptr %ch, ptr nonnull %chan.value, ptr nonnull %chan.blockedList, ptr undef) #3
-  call void @llvm.lifetime.start.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
+  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %chan.value)
-  %0 = call i1 @runtime.chanRecv(%runtime.channel* %ch, i8* nonnull %chan.value.bitcast, %runtime.channelBlockedList* nonnull %chan.blockedList, i8* undef) #3
+  call void @llvm.lifetime.end.p0(i64 24, ptr nonnull %chan.blockedList)
-  call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull %chan.value.bitcast)
-  call void @llvm.lifetime.end.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
   ret void
 }
 
-declare i1 @runtime.chanRecv(%runtime.channel* dereferenceable_or_null(32), i8*, %runtime.channelBlockedList* dereferenceable_or_null(24), i8*) #0
+declare i1 @runtime.chanRecv(ptr dereferenceable_or_null(32), ptr, ptr dereferenceable_or_null(24), ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.chanZeroSend(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context) unnamed_addr #1 {
+define hidden void @main.chanZeroSend(ptr dereferenceable_or_null(32) %ch, ptr %context) unnamed_addr #1 {
 entry:
   %complit = alloca {}, align 8
   %chan.blockedList = alloca %runtime.channelBlockedList, align 8
-  %0 = bitcast {}* %complit to i8*
+  %stackalloc = alloca i8, align 1
-  call void @runtime.trackPointer(i8* nonnull %0, i8* undef) #3
+  call void @runtime.trackPointer(ptr nonnull %complit, ptr nonnull %stackalloc, ptr undef) #3
-  %chan.blockedList.bitcast = bitcast %runtime.channelBlockedList* %chan.blockedList to i8*
+  call void @llvm.lifetime.start.p0(i64 24, ptr nonnull %chan.blockedList)
-  call void @llvm.lifetime.start.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
+  call void @runtime.chanSend(ptr %ch, ptr null, ptr nonnull %chan.blockedList, ptr undef) #3
-  call void @runtime.chanSend(%runtime.channel* %ch, i8* null, %runtime.channelBlockedList* nonnull %chan.blockedList, i8* undef) #3
+  call void @llvm.lifetime.end.p0(i64 24, ptr nonnull %chan.blockedList)
-  call void @llvm.lifetime.end.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.chanZeroRecv(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context) unnamed_addr #1 {
+define hidden void @main.chanZeroRecv(ptr dereferenceable_or_null(32) %ch, ptr %context) unnamed_addr #1 {
 entry:
   %chan.blockedList = alloca %runtime.channelBlockedList, align 8
-  %chan.blockedList.bitcast = bitcast %runtime.channelBlockedList* %chan.blockedList to i8*
+  call void @llvm.lifetime.start.p0(i64 24, ptr nonnull %chan.blockedList)
-  call void @llvm.lifetime.start.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
+  %0 = call i1 @runtime.chanRecv(ptr %ch, ptr null, ptr nonnull %chan.blockedList, ptr undef) #3
-  %0 = call i1 @runtime.chanRecv(%runtime.channel* %ch, i8* null, %runtime.channelBlockedList* nonnull %chan.blockedList, i8* undef) #3
+  call void @llvm.lifetime.end.p0(i64 24, ptr nonnull %chan.blockedList)
-  call void @llvm.lifetime.end.p0i8(i64 24, i8* nonnull %chan.blockedList.bitcast)
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.selectZeroRecv(%runtime.channel* dereferenceable_or_null(32) %ch1, %runtime.channel* dereferenceable_or_null(32) %ch2, i8* %context) unnamed_addr #1 {
+define hidden void @main.selectZeroRecv(ptr dereferenceable_or_null(32) %ch1, ptr dereferenceable_or_null(32) %ch2, ptr %context) unnamed_addr #1 {
 entry:
   %select.states.alloca = alloca [2 x %runtime.chanSelectState], align 8
   %select.send.value = alloca i32, align 4
-  store i32 1, i32* %select.send.value, align 4
+  store i32 1, ptr %select.send.value, align 4
-  %select.states.alloca.bitcast = bitcast [2 x %runtime.chanSelectState]* %select.states.alloca to i8*
+  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %select.states.alloca)
-  call void @llvm.lifetime.start.p0i8(i64 16, i8* nonnull %select.states.alloca.bitcast)
+  store ptr %ch1, ptr %select.states.alloca, align 8
-  %.repack = getelementptr inbounds [2 x %runtime.chanSelectState], [2 x %runtime.chanSelectState]* %select.states.alloca, i32 0, i32 0, i32 0
+  %select.states.alloca.repack1 = getelementptr inbounds %runtime.chanSelectState, ptr %select.states.alloca, i32 0, i32 1
-  store %runtime.channel* %ch1, %runtime.channel** %.repack, align 8
+  store ptr %select.send.value, ptr %select.states.alloca.repack1, align 4
-  %.repack1 = getelementptr inbounds [2 x %runtime.chanSelectState], [2 x %runtime.chanSelectState]* %select.states.alloca, i32 0, i32 0, i32 1
+  %0 = getelementptr inbounds [2 x %runtime.chanSelectState], ptr %select.states.alloca, i32 0, i32 1
-  %0 = bitcast i8** %.repack1 to i32**
+  store ptr %ch2, ptr %0, align 8
-  store i32* %select.send.value, i32** %0, align 4
+  %.repack3 = getelementptr inbounds [2 x %runtime.chanSelectState], ptr %select.states.alloca, i32 0, i32 1, i32 1
-  %.repack3 = getelementptr inbounds [2 x %runtime.chanSelectState], [2 x %runtime.chanSelectState]* %select.states.alloca, i32 0, i32 1, i32 0
+  store ptr null, ptr %.repack3, align 4
-  store %runtime.channel* %ch2, %runtime.channel** %.repack3, align 8
+  %select.result = call { i32, i1 } @runtime.tryChanSelect(ptr undef, ptr nonnull %select.states.alloca, i32 2, i32 2, ptr undef) #3
-  %.repack4 = getelementptr inbounds [2 x %runtime.chanSelectState], [2 x %runtime.chanSelectState]* %select.states.alloca, i32 0, i32 1, i32 1
+  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %select.states.alloca)
-  store i8* null, i8** %.repack4, align 4
-  %select.states = getelementptr inbounds [2 x %runtime.chanSelectState], [2 x %runtime.chanSelectState]* %select.states.alloca, i32 0, i32 0
-  %select.result = call { i32, i1 } @runtime.tryChanSelect(i8* undef, %runtime.chanSelectState* nonnull %select.states, i32 2, i32 2, i8* undef) #3
-  call void @llvm.lifetime.end.p0i8(i64 16, i8* nonnull %select.states.alloca.bitcast)
   %1 = extractvalue { i32, i1 } %select.result, 0
   %2 = icmp eq i32 %1, 0
   br i1 %2, label %select.done, label %select.next
@@ -122,9 +107,9 @@ select.body:                                      ; preds = %select.next
   br label %select.done
 }
 
-declare { i32, i1 } @runtime.tryChanSelect(i8*, %runtime.chanSelectState*, i32, i32, i8*) #0
+declare { i32, i1 } @runtime.tryChanSelect(ptr, ptr, i32, i32, ptr) #0
 
 attributes #0 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
 attributes #1 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
-attributes #2 = { argmemonly nofree nosync nounwind willreturn }
+attributes #2 = { argmemonly nocallback nofree nosync nounwind willreturn }
 attributes #3 = { nounwind }

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

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

compiler/testdata/float.ll

@@ -3,18 +3,18 @@ source_filename = "float.go"
 target datalayout = "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-n32:64-S128-ni:1:10:20"
 target triple = "wasm32-unknown-wasi"
 
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*) #0
+declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #0
 
-declare void @runtime.trackPointer(i8* nocapture readonly, i8*) #0
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.init(i8* %context) unnamed_addr #1 {
+define hidden void @main.init(ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.f32tou32(float %v, i8* %context) unnamed_addr #1 {
+define hidden i32 @main.f32tou32(float %v, ptr %context) unnamed_addr #1 {
 entry:
   %positive = fcmp oge float %v, 0.000000e+00
   %withinmax = fcmp ole float %v, 0x41EFFFFFC0000000
@@ -26,25 +26,25 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden float @main.maxu32f(i8* %context) unnamed_addr #1 {
+define hidden float @main.maxu32f(ptr %context) unnamed_addr #1 {
 entry:
   ret float 0x41F0000000000000
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.maxu32tof32(i8* %context) unnamed_addr #1 {
+define hidden i32 @main.maxu32tof32(ptr %context) unnamed_addr #1 {
 entry:
   ret i32 -1
 }
 
 ; Function Attrs: nounwind
-define hidden { i32, i32, i32, i32 } @main.inftoi32(i8* %context) unnamed_addr #1 {
+define hidden { i32, i32, i32, i32 } @main.inftoi32(ptr %context) unnamed_addr #1 {
 entry:
   ret { i32, i32, i32, i32 } { i32 -1, i32 0, i32 2147483647, i32 -2147483648 }
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.u32tof32tou32(i32 %v, i8* %context) unnamed_addr #1 {
+define hidden i32 @main.u32tof32tou32(i32 %v, ptr %context) unnamed_addr #1 {
 entry:
   %0 = uitofp i32 %v to float
   %withinmax = fcmp ole float %0, 0x41EFFFFFC0000000
@@ -54,7 +54,7 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden float @main.f32tou32tof32(float %v, i8* %context) unnamed_addr #1 {
+define hidden float @main.f32tou32tof32(float %v, ptr %context) unnamed_addr #1 {
 entry:
   %positive = fcmp oge float %v, 0.000000e+00
   %withinmax = fcmp ole float %v, 0x41EFFFFFC0000000
@@ -67,7 +67,7 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden i8 @main.f32tou8(float %v, i8* %context) unnamed_addr #1 {
+define hidden i8 @main.f32tou8(float %v, ptr %context) unnamed_addr #1 {
 entry:
   %positive = fcmp oge float %v, 0.000000e+00
   %withinmax = fcmp ole float %v, 2.550000e+02
@@ -79,7 +79,7 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden i8 @main.f32toi8(float %v, i8* %context) unnamed_addr #1 {
+define hidden i8 @main.f32toi8(float %v, ptr %context) unnamed_addr #1 {
 entry:
   %abovemin = fcmp oge float %v, -1.280000e+02
   %belowmax = fcmp ole float %v, 1.270000e+02

compiler/testdata/func.ll

@@ -3,43 +3,42 @@ source_filename = "func.go"
 target datalayout = "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-n32:64-S128-ni:1:10:20"
 target triple = "wasm32-unknown-wasi"
 
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*) #0
+declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #0
 
-declare void @runtime.trackPointer(i8* nocapture readonly, i8*) #0
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.init(i8* %context) unnamed_addr #1 {
+define hidden void @main.init(ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.foo(i8* %callback.context, void ()* %callback.funcptr, i8* %context) unnamed_addr #1 {
+define hidden void @main.foo(ptr %callback.context, ptr %callback.funcptr, ptr %context) unnamed_addr #1 {
 entry:
-  %0 = icmp eq void ()* %callback.funcptr, null
+  %0 = icmp eq ptr %callback.funcptr, null
   br i1 %0, label %fpcall.throw, label %fpcall.next
 
 fpcall.next:                                      ; preds = %entry
-  %1 = bitcast void ()* %callback.funcptr to void (i32, i8*)*
+  call void %callback.funcptr(i32 3, ptr %callback.context) #2
-  call void %1(i32 3, i8* %callback.context) #2
   ret void
 
 fpcall.throw:                                     ; preds = %entry
-  call void @runtime.nilPanic(i8* undef) #2
+  call void @runtime.nilPanic(ptr undef) #2
   unreachable
 }
 
-declare void @runtime.nilPanic(i8*) #0
+declare void @runtime.nilPanic(ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.bar(i8* %context) unnamed_addr #1 {
+define hidden void @main.bar(ptr %context) unnamed_addr #1 {
 entry:
-  call void @main.foo(i8* undef, void ()* bitcast (void (i32, i8*)* @main.someFunc to void ()*), i8* undef)
+  call void @main.foo(ptr undef, ptr nonnull @main.someFunc, ptr undef)
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.someFunc(i32 %arg0, i8* %context) unnamed_addr #1 {
+define hidden void @main.someFunc(i32 %arg0, ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }

compiler/testdata/gc.ll

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

compiler/testdata/go1.20.go

@@ -0,0 +1,15 @@
+package main
+
+import "unsafe"
+
+func unsafeSliceData(s []int) *int {
+	return unsafe.SliceData(s)
+}
+
+func unsafeString(ptr *byte, len int16) string {
+	return unsafe.String(ptr, len)
+}
+
+func unsafeStringData(s string) *byte {
+	return unsafe.StringData(s)
+}

compiler/testdata/go1.20.ll

@@ -0,0 +1,61 @@
+; ModuleID = 'go1.20.go'
+source_filename = "go1.20.go"
+target datalayout = "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-n32:64-S128-ni:1:10:20"
+target triple = "wasm32-unknown-wasi"
+
+%runtime._string = type { ptr, i32 }
+
+declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #0
+
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #0
+
+; Function Attrs: nounwind
+define hidden void @main.init(ptr %context) unnamed_addr #1 {
+entry:
+  ret void
+}
+
+; Function Attrs: nounwind
+define hidden ptr @main.unsafeSliceData(ptr %s.data, i32 %s.len, i32 %s.cap, ptr %context) unnamed_addr #1 {
+entry:
+  %stackalloc = alloca i8, align 1
+  call void @runtime.trackPointer(ptr %s.data, ptr nonnull %stackalloc, ptr undef) #2
+  ret ptr %s.data
+}
+
+; Function Attrs: nounwind
+define hidden %runtime._string @main.unsafeString(ptr dereferenceable_or_null(1) %ptr, i16 %len, ptr %context) unnamed_addr #1 {
+entry:
+  %stackalloc = alloca i8, align 1
+  %0 = icmp slt i16 %len, 0
+  %1 = icmp eq ptr %ptr, null
+  %2 = icmp ne i16 %len, 0
+  %3 = and i1 %1, %2
+  %4 = or i1 %3, %0
+  br i1 %4, label %unsafe.String.throw, label %unsafe.String.next
+
+unsafe.String.next:                               ; preds = %entry
+  %5 = zext i16 %len to i32
+  %6 = insertvalue %runtime._string undef, ptr %ptr, 0
+  %7 = insertvalue %runtime._string %6, i32 %5, 1
+  call void @runtime.trackPointer(ptr %ptr, ptr nonnull %stackalloc, ptr undef) #2
+  ret %runtime._string %7
+
+unsafe.String.throw:                              ; preds = %entry
+  call void @runtime.unsafeSlicePanic(ptr undef) #2
+  unreachable
+}
+
+declare void @runtime.unsafeSlicePanic(ptr) #0
+
+; Function Attrs: nounwind
+define hidden ptr @main.unsafeStringData(ptr %s.data, i32 %s.len, ptr %context) unnamed_addr #1 {
+entry:
+  %stackalloc = alloca i8, align 1
+  call void @runtime.trackPointer(ptr %s.data, ptr nonnull %stackalloc, ptr undef) #2
+  ret ptr %s.data
+}
+
+attributes #0 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #1 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
+attributes #2 = { nounwind }

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

@@ -3,201 +3,176 @@ source_filename = "goroutine.go"
 target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
 target triple = "thumbv7m-unknown-unknown-eabi"
 
-%runtime.channel = type { i32, i32, i8, %runtime.channelBlockedList*, i32, i32, i32, i8* }
+%runtime._string = type { ptr, i32 }
-%runtime.channelBlockedList = type { %runtime.channelBlockedList*, %"internal/task.Task"*, %runtime.chanSelectState*, { %runtime.channelBlockedList*, i32, i32 } }
-%"internal/task.Task" = type { %"internal/task.Task"*, i8*, i64, %"internal/task.gcData", %"internal/task.state", i8* }
-%"internal/task.gcData" = type {}
-%"internal/task.state" = type { i32, i32* }
-%runtime.chanSelectState = type { %runtime.channel*, i8* }
 
 @"main$string" = internal unnamed_addr constant [4 x i8] c"test", align 1
 
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*) #0
+declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.init(i8* %context) unnamed_addr #1 {
+define hidden void @main.init(ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.regularFunctionGoroutine(i8* %context) unnamed_addr #1 {
+define hidden void @main.regularFunctionGoroutine(ptr %context) unnamed_addr #1 {
 entry:
-  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @"main.regularFunction$gowrapper" to i32), i8* undef) #8
+  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (ptr @"main.regularFunction$gowrapper" to i32), ptr undef) #8
-  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"main.regularFunction$gowrapper" to i32), i8* nonnull inttoptr (i32 5 to i8*), i32 %stacksize, i8* undef) #8
+  call void @"internal/task.start"(i32 ptrtoint (ptr @"main.regularFunction$gowrapper" to i32), ptr nonnull inttoptr (i32 5 to ptr), i32 %stacksize, ptr undef) #8
   ret void
 }
 
-declare void @main.regularFunction(i32, i8*) #0
+declare void @main.regularFunction(i32, ptr) #0
 
 ; Function Attrs: nounwind
-define linkonce_odr void @"main.regularFunction$gowrapper"(i8* %0) unnamed_addr #2 {
+define linkonce_odr void @"main.regularFunction$gowrapper"(ptr %0) unnamed_addr #2 {
 entry:
-  %unpack.int = ptrtoint i8* %0 to i32
+  %unpack.int = ptrtoint ptr %0 to i32
-  call void @main.regularFunction(i32 %unpack.int, i8* undef) #8
+  call void @main.regularFunction(i32 %unpack.int, ptr undef) #8
   ret void
 }
 
-declare i32 @"internal/task.getGoroutineStackSize"(i32, i8*) #0
+declare i32 @"internal/task.getGoroutineStackSize"(i32, ptr) #0
 
-declare void @"internal/task.start"(i32, i8*, i32, i8*) #0
+declare void @"internal/task.start"(i32, ptr, i32, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.inlineFunctionGoroutine(i8* %context) unnamed_addr #1 {
+define hidden void @main.inlineFunctionGoroutine(ptr %context) unnamed_addr #1 {
 entry:
-  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @"main.inlineFunctionGoroutine$1$gowrapper" to i32), i8* undef) #8
+  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (ptr @"main.inlineFunctionGoroutine$1$gowrapper" to i32), ptr undef) #8
-  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"main.inlineFunctionGoroutine$1$gowrapper" to i32), i8* nonnull inttoptr (i32 5 to i8*), i32 %stacksize, i8* undef) #8
+  call void @"internal/task.start"(i32 ptrtoint (ptr @"main.inlineFunctionGoroutine$1$gowrapper" to i32), ptr nonnull inttoptr (i32 5 to ptr), i32 %stacksize, ptr undef) #8
   ret void
 }
 
 ; Function Attrs: nounwind
-define internal void @"main.inlineFunctionGoroutine$1"(i32 %x, i8* %context) unnamed_addr #1 {
+define internal void @"main.inlineFunctionGoroutine$1"(i32 %x, ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define linkonce_odr void @"main.inlineFunctionGoroutine$1$gowrapper"(i8* %0) unnamed_addr #3 {
+define linkonce_odr void @"main.inlineFunctionGoroutine$1$gowrapper"(ptr %0) unnamed_addr #3 {
 entry:
-  %unpack.int = ptrtoint i8* %0 to i32
+  %unpack.int = ptrtoint ptr %0 to i32
-  call void @"main.inlineFunctionGoroutine$1"(i32 %unpack.int, i8* undef)
+  call void @"main.inlineFunctionGoroutine$1"(i32 %unpack.int, ptr undef)
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.closureFunctionGoroutine(i8* %context) unnamed_addr #1 {
+define hidden void @main.closureFunctionGoroutine(ptr %context) unnamed_addr #1 {
 entry:
-  %n = call i8* @runtime.alloc(i32 4, i8* nonnull inttoptr (i32 3 to i8*), i8* undef) #8
+  %n = call ptr @runtime.alloc(i32 4, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #8
-  %0 = bitcast i8* %n to i32*
+  store i32 3, ptr %n, align 4
-  store i32 3, i32* %0, align 4
+  %0 = call ptr @runtime.alloc(i32 8, ptr null, ptr undef) #8
-  %1 = call i8* @runtime.alloc(i32 8, i8* null, i8* undef) #8
+  store i32 5, ptr %0, align 4
-  %2 = bitcast i8* %1 to i32*
+  %1 = getelementptr inbounds { i32, ptr }, ptr %0, i32 0, i32 1
-  store i32 5, i32* %2, align 4
+  store ptr %n, ptr %1, align 4
-  %3 = getelementptr inbounds i8, i8* %1, i32 4
+  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (ptr @"main.closureFunctionGoroutine$1$gowrapper" to i32), ptr undef) #8
-  %4 = bitcast i8* %3 to i8**
+  call void @"internal/task.start"(i32 ptrtoint (ptr @"main.closureFunctionGoroutine$1$gowrapper" to i32), ptr nonnull %0, i32 %stacksize, ptr undef) #8
-  store i8* %n, i8** %4, align 4
+  %2 = load i32, ptr %n, align 4
-  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @"main.closureFunctionGoroutine$1$gowrapper" to i32), i8* undef) #8
+  call void @runtime.printint32(i32 %2, ptr undef) #8
-  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"main.closureFunctionGoroutine$1$gowrapper" to i32), i8* nonnull %1, i32 %stacksize, i8* undef) #8
-  %5 = load i32, i32* %0, align 4
-  call void @runtime.printint32(i32 %5, i8* undef) #8
   ret void
 }
 
 ; Function Attrs: nounwind
-define internal void @"main.closureFunctionGoroutine$1"(i32 %x, i8* %context) unnamed_addr #1 {
+define internal void @"main.closureFunctionGoroutine$1"(i32 %x, ptr %context) unnamed_addr #1 {
 entry:
-  %unpack.ptr = bitcast i8* %context to i32*
+  store i32 7, ptr %context, align 4
-  store i32 7, i32* %unpack.ptr, align 4
   ret void
 }
 
 ; Function Attrs: nounwind
-define linkonce_odr void @"main.closureFunctionGoroutine$1$gowrapper"(i8* %0) unnamed_addr #4 {
+define linkonce_odr void @"main.closureFunctionGoroutine$1$gowrapper"(ptr %0) unnamed_addr #4 {
 entry:
-  %1 = bitcast i8* %0 to i32*
+  %1 = load i32, ptr %0, align 4
-  %2 = load i32, i32* %1, align 4
+  %2 = getelementptr inbounds { i32, ptr }, ptr %0, i32 0, i32 1
-  %3 = getelementptr inbounds i8, i8* %0, i32 4
+  %3 = load ptr, ptr %2, align 4
-  %4 = bitcast i8* %3 to i8**
+  call void @"main.closureFunctionGoroutine$1"(i32 %1, ptr %3)
-  %5 = load i8*, i8** %4, align 4
-  call void @"main.closureFunctionGoroutine$1"(i32 %2, i8* %5)
   ret void
 }
 
-declare void @runtime.printint32(i32, i8*) #0
+declare void @runtime.printint32(i32, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.funcGoroutine(i8* %fn.context, void ()* %fn.funcptr, i8* %context) unnamed_addr #1 {
+define hidden void @main.funcGoroutine(ptr %fn.context, ptr %fn.funcptr, ptr %context) unnamed_addr #1 {
 entry:
-  %0 = call i8* @runtime.alloc(i32 12, i8* null, i8* undef) #8
+  %0 = call ptr @runtime.alloc(i32 12, ptr null, ptr undef) #8
-  %1 = bitcast i8* %0 to i32*
+  store i32 5, ptr %0, align 4
-  store i32 5, i32* %1, align 4
+  %1 = getelementptr inbounds { i32, ptr, ptr }, ptr %0, i32 0, i32 1
-  %2 = getelementptr inbounds i8, i8* %0, i32 4
+  store ptr %fn.context, ptr %1, align 4
-  %3 = bitcast i8* %2 to i8**
+  %2 = getelementptr inbounds { i32, ptr, ptr }, ptr %0, i32 0, i32 2
-  store i8* %fn.context, i8** %3, align 4
+  store ptr %fn.funcptr, ptr %2, align 4
-  %4 = getelementptr inbounds i8, i8* %0, i32 8
+  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (ptr @main.funcGoroutine.gowrapper to i32), ptr undef) #8
-  %5 = bitcast i8* %4 to void ()**
+  call void @"internal/task.start"(i32 ptrtoint (ptr @main.funcGoroutine.gowrapper to i32), ptr nonnull %0, i32 %stacksize, ptr undef) #8
-  store void ()* %fn.funcptr, void ()** %5, align 4
-  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @main.funcGoroutine.gowrapper to i32), i8* undef) #8
-  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @main.funcGoroutine.gowrapper to i32), i8* nonnull %0, i32 %stacksize, i8* undef) #8
   ret void
 }
 
 ; Function Attrs: nounwind
-define linkonce_odr void @main.funcGoroutine.gowrapper(i8* %0) unnamed_addr #5 {
+define linkonce_odr void @main.funcGoroutine.gowrapper(ptr %0) unnamed_addr #5 {
 entry:
-  %1 = bitcast i8* %0 to i32*
+  %1 = load i32, ptr %0, align 4
-  %2 = load i32, i32* %1, align 4
+  %2 = getelementptr inbounds { i32, ptr, ptr }, ptr %0, i32 0, i32 1
-  %3 = getelementptr inbounds i8, i8* %0, i32 4
+  %3 = load ptr, ptr %2, align 4
-  %4 = bitcast i8* %3 to i8**
+  %4 = getelementptr inbounds { i32, ptr, ptr }, ptr %0, i32 0, i32 2
-  %5 = load i8*, i8** %4, align 4
+  %5 = load ptr, ptr %4, align 4
-  %6 = getelementptr inbounds i8, i8* %0, i32 8
+  call void %5(i32 %1, ptr %3) #8
-  %7 = bitcast i8* %6 to void (i32, i8*)**
-  %8 = load void (i32, i8*)*, void (i32, i8*)** %7, align 4
-  call void %8(i32 %2, i8* %5) #8
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.recoverBuiltinGoroutine(i8* %context) unnamed_addr #1 {
+define hidden void @main.recoverBuiltinGoroutine(ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.copyBuiltinGoroutine(i8* %dst.data, i32 %dst.len, i32 %dst.cap, i8* %src.data, i32 %src.len, i32 %src.cap, i8* %context) unnamed_addr #1 {
+define hidden void @main.copyBuiltinGoroutine(ptr %dst.data, i32 %dst.len, i32 %dst.cap, ptr %src.data, i32 %src.len, i32 %src.cap, ptr %context) unnamed_addr #1 {
 entry:
-  %copy.n = call i32 @runtime.sliceCopy(i8* %dst.data, i8* %src.data, i32 %dst.len, i32 %src.len, i32 1, i8* undef) #8
+  %copy.n = call i32 @runtime.sliceCopy(ptr %dst.data, ptr %src.data, i32 %dst.len, i32 %src.len, i32 1, ptr undef) #8
   ret void
 }
 
-declare i32 @runtime.sliceCopy(i8* nocapture writeonly, i8* nocapture readonly, i32, i32, i32, i8*) #0
+declare i32 @runtime.sliceCopy(ptr nocapture writeonly, ptr nocapture readonly, i32, i32, i32, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.closeBuiltinGoroutine(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context) unnamed_addr #1 {
+define hidden void @main.closeBuiltinGoroutine(ptr dereferenceable_or_null(32) %ch, ptr %context) unnamed_addr #1 {
 entry:
-  call void @runtime.chanClose(%runtime.channel* %ch, i8* undef) #8
+  call void @runtime.chanClose(ptr %ch, ptr undef) #8
   ret void
 }
 
-declare void @runtime.chanClose(%runtime.channel* dereferenceable_or_null(32), i8*) #0
+declare void @runtime.chanClose(ptr dereferenceable_or_null(32), ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.startInterfaceMethod(i32 %itf.typecode, i8* %itf.value, i8* %context) unnamed_addr #1 {
+define hidden void @main.startInterfaceMethod(i32 %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
 entry:
-  %0 = call i8* @runtime.alloc(i32 16, i8* null, i8* undef) #8
+  %0 = call ptr @runtime.alloc(i32 16, ptr null, ptr undef) #8
-  %1 = bitcast i8* %0 to i8**
+  store ptr %itf.value, ptr %0, align 4
-  store i8* %itf.value, i8** %1, align 4
+  %1 = getelementptr inbounds { ptr, %runtime._string, i32 }, ptr %0, i32 0, i32 1
-  %2 = getelementptr inbounds i8, i8* %0, i32 4
+  store ptr @"main$string", ptr %1, align 4
-  %.repack = bitcast i8* %2 to i8**
+  %.repack1 = getelementptr inbounds { ptr, %runtime._string, i32 }, ptr %0, i32 0, i32 1, i32 1
-  store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @"main$string", i32 0, i32 0), i8** %.repack, align 4
+  store i32 4, ptr %.repack1, align 4
-  %.repack1 = getelementptr inbounds i8, i8* %0, i32 8
+  %2 = getelementptr inbounds { ptr, %runtime._string, i32 }, ptr %0, i32 0, i32 2
-  %3 = bitcast i8* %.repack1 to i32*
+  store i32 %itf.typecode, ptr %2, align 4
-  store i32 4, i32* %3, align 4
+  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (ptr @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper" to i32), ptr undef) #8
-  %4 = getelementptr inbounds i8, i8* %0, i32 12
+  call void @"internal/task.start"(i32 ptrtoint (ptr @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper" to i32), ptr nonnull %0, i32 %stacksize, ptr undef) #8
-  %5 = bitcast i8* %4 to i32*
-  store i32 %itf.typecode, i32* %5, align 4
-  %stacksize = call i32 @"internal/task.getGoroutineStackSize"(i32 ptrtoint (void (i8*)* @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper" to i32), i8* undef) #8
-  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper" to i32), i8* nonnull %0, i32 %stacksize, i8* undef) #8
   ret void
 }
 
-declare void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(i8*, i8*, i32, i32, i8*) #6
+declare void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(ptr, ptr, i32, i32, ptr) #6
 
 ; Function Attrs: nounwind
-define linkonce_odr void @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper"(i8* %0) unnamed_addr #7 {
+define linkonce_odr void @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper"(ptr %0) unnamed_addr #7 {
 entry:
-  %1 = bitcast i8* %0 to i8**
+  %1 = load ptr, ptr %0, align 4
-  %2 = load i8*, i8** %1, align 4
+  %2 = getelementptr inbounds { ptr, ptr, i32, i32 }, ptr %0, i32 0, i32 1
-  %3 = getelementptr inbounds i8, i8* %0, i32 4
+  %3 = load ptr, ptr %2, align 4
-  %4 = bitcast i8* %3 to i8**
+  %4 = getelementptr inbounds { ptr, ptr, i32, i32 }, ptr %0, i32 0, i32 2
-  %5 = load i8*, i8** %4, align 4
+  %5 = load i32, ptr %4, align 4
-  %6 = getelementptr inbounds i8, i8* %0, i32 8
+  %6 = getelementptr inbounds { ptr, ptr, i32, i32 }, ptr %0, i32 0, i32 3
-  %7 = bitcast i8* %6 to i32*
+  %7 = load i32, ptr %6, align 4
-  %8 = load i32, i32* %7, align 4
+  call void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(ptr %1, ptr %3, i32 %5, i32 %7, ptr undef) #8
-  %9 = getelementptr inbounds i8, i8* %0, i32 12
-  %10 = bitcast i8* %9 to i32*
-  %11 = load i32, i32* %10, align 4
-  call void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(i8* %2, i8* %5, i32 %8, i32 %11, i8* undef) #8
   ret void
 }
 

compiler/testdata/goroutine-wasm-asyncify.ll

@@ -3,210 +3,187 @@ source_filename = "goroutine.go"
 target datalayout = "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-n32:64-S128-ni:1:10:20"
 target triple = "wasm32-unknown-wasi"
 
-%runtime.channel = type { i32, i32, i8, %runtime.channelBlockedList*, i32, i32, i32, i8* }
+%runtime._string = type { ptr, i32 }
-%runtime.channelBlockedList = type { %runtime.channelBlockedList*, %"internal/task.Task"*, %runtime.chanSelectState*, { %runtime.channelBlockedList*, i32, i32 } }
-%"internal/task.Task" = type { %"internal/task.Task"*, i8*, i64, %"internal/task.gcData", %"internal/task.state", i8* }
-%"internal/task.gcData" = type { i8* }
-%"internal/task.state" = type { i32, i8*, %"internal/task.stackState", i1 }
-%"internal/task.stackState" = type { i32, i32 }
-%runtime.chanSelectState = type { %runtime.channel*, i8* }
 
 @"main$string" = internal unnamed_addr constant [4 x i8] c"test", align 1
 
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*) #0
+declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #0
 
-declare void @runtime.trackPointer(i8* nocapture readonly, i8*) #0
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.init(i8* %context) unnamed_addr #1 {
+define hidden void @main.init(ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.regularFunctionGoroutine(i8* %context) unnamed_addr #1 {
+define hidden void @main.regularFunctionGoroutine(ptr %context) unnamed_addr #1 {
 entry:
-  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"main.regularFunction$gowrapper" to i32), i8* nonnull inttoptr (i32 5 to i8*), i32 16384, i8* undef) #8
+  call void @"internal/task.start"(i32 ptrtoint (ptr @"main.regularFunction$gowrapper" to i32), ptr nonnull inttoptr (i32 5 to ptr), i32 16384, ptr undef) #8
   ret void
 }
 
-declare void @main.regularFunction(i32, i8*) #0
+declare void @main.regularFunction(i32, ptr) #0
 
-declare void @runtime.deadlock(i8*) #0
+declare void @runtime.deadlock(ptr) #0
 
 ; Function Attrs: nounwind
-define linkonce_odr void @"main.regularFunction$gowrapper"(i8* %0) unnamed_addr #2 {
+define linkonce_odr void @"main.regularFunction$gowrapper"(ptr %0) unnamed_addr #2 {
 entry:
-  %unpack.int = ptrtoint i8* %0 to i32
+  %unpack.int = ptrtoint ptr %0 to i32
-  call void @main.regularFunction(i32 %unpack.int, i8* undef) #8
+  call void @main.regularFunction(i32 %unpack.int, ptr undef) #8
-  call void @runtime.deadlock(i8* undef) #8
+  call void @runtime.deadlock(ptr undef) #8
   unreachable
 }
 
-declare void @"internal/task.start"(i32, i8*, i32, i8*) #0
+declare void @"internal/task.start"(i32, ptr, i32, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.inlineFunctionGoroutine(i8* %context) unnamed_addr #1 {
+define hidden void @main.inlineFunctionGoroutine(ptr %context) unnamed_addr #1 {
 entry:
-  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"main.inlineFunctionGoroutine$1$gowrapper" to i32), i8* nonnull inttoptr (i32 5 to i8*), i32 16384, i8* undef) #8
+  call void @"internal/task.start"(i32 ptrtoint (ptr @"main.inlineFunctionGoroutine$1$gowrapper" to i32), ptr nonnull inttoptr (i32 5 to ptr), i32 16384, ptr undef) #8
   ret void
 }
 
 ; Function Attrs: nounwind
-define internal void @"main.inlineFunctionGoroutine$1"(i32 %x, i8* %context) unnamed_addr #1 {
+define internal void @"main.inlineFunctionGoroutine$1"(i32 %x, ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define linkonce_odr void @"main.inlineFunctionGoroutine$1$gowrapper"(i8* %0) unnamed_addr #3 {
+define linkonce_odr void @"main.inlineFunctionGoroutine$1$gowrapper"(ptr %0) unnamed_addr #3 {
 entry:
-  %unpack.int = ptrtoint i8* %0 to i32
+  %unpack.int = ptrtoint ptr %0 to i32
-  call void @"main.inlineFunctionGoroutine$1"(i32 %unpack.int, i8* undef)
+  call void @"main.inlineFunctionGoroutine$1"(i32 %unpack.int, ptr undef)
-  call void @runtime.deadlock(i8* undef) #8
+  call void @runtime.deadlock(ptr undef) #8
   unreachable
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.closureFunctionGoroutine(i8* %context) unnamed_addr #1 {
+define hidden void @main.closureFunctionGoroutine(ptr %context) unnamed_addr #1 {
 entry:
-  %n = call i8* @runtime.alloc(i32 4, i8* nonnull inttoptr (i32 3 to i8*), i8* undef) #8
+  %stackalloc = alloca i8, align 1
-  %0 = bitcast i8* %n to i32*
+  %n = call ptr @runtime.alloc(i32 4, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #8
-  call void @runtime.trackPointer(i8* nonnull %n, i8* undef) #8
+  call void @runtime.trackPointer(ptr nonnull %n, ptr nonnull %stackalloc, ptr undef) #8
-  store i32 3, i32* %0, align 4
+  store i32 3, ptr %n, align 4
-  call void @runtime.trackPointer(i8* nonnull %n, i8* undef) #8
+  call void @runtime.trackPointer(ptr nonnull %n, ptr nonnull %stackalloc, ptr undef) #8
-  call void @runtime.trackPointer(i8* bitcast (void (i32, i8*)* @"main.closureFunctionGoroutine$1" to i8*), i8* undef) #8
+  call void @runtime.trackPointer(ptr nonnull @"main.closureFunctionGoroutine$1", ptr nonnull %stackalloc, ptr undef) #8
-  %1 = call i8* @runtime.alloc(i32 8, i8* null, i8* undef) #8
+  %0 = call ptr @runtime.alloc(i32 8, ptr null, ptr undef) #8
-  call void @runtime.trackPointer(i8* nonnull %1, i8* undef) #8
+  call void @runtime.trackPointer(ptr nonnull %0, ptr nonnull %stackalloc, ptr undef) #8
-  %2 = bitcast i8* %1 to i32*
+  store i32 5, ptr %0, align 4
-  store i32 5, i32* %2, align 4
+  %1 = getelementptr inbounds { i32, ptr }, ptr %0, i32 0, i32 1
-  %3 = getelementptr inbounds i8, i8* %1, i32 4
+  store ptr %n, ptr %1, align 4
-  %4 = bitcast i8* %3 to i8**
+  call void @"internal/task.start"(i32 ptrtoint (ptr @"main.closureFunctionGoroutine$1$gowrapper" to i32), ptr nonnull %0, i32 16384, ptr undef) #8
-  store i8* %n, i8** %4, align 4
+  %2 = load i32, ptr %n, align 4
-  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"main.closureFunctionGoroutine$1$gowrapper" to i32), i8* nonnull %1, i32 16384, i8* undef) #8
+  call void @runtime.printint32(i32 %2, ptr undef) #8
-  %5 = load i32, i32* %0, align 4
-  call void @runtime.printint32(i32 %5, i8* undef) #8
   ret void
 }
 
 ; Function Attrs: nounwind
-define internal void @"main.closureFunctionGoroutine$1"(i32 %x, i8* %context) unnamed_addr #1 {
+define internal void @"main.closureFunctionGoroutine$1"(i32 %x, ptr %context) unnamed_addr #1 {
 entry:
-  %unpack.ptr = bitcast i8* %context to i32*
+  store i32 7, ptr %context, align 4
-  store i32 7, i32* %unpack.ptr, align 4
   ret void
 }
 
 ; Function Attrs: nounwind
-define linkonce_odr void @"main.closureFunctionGoroutine$1$gowrapper"(i8* %0) unnamed_addr #4 {
+define linkonce_odr void @"main.closureFunctionGoroutine$1$gowrapper"(ptr %0) unnamed_addr #4 {
 entry:
-  %1 = bitcast i8* %0 to i32*
+  %1 = load i32, ptr %0, align 4
-  %2 = load i32, i32* %1, align 4
+  %2 = getelementptr inbounds { i32, ptr }, ptr %0, i32 0, i32 1
-  %3 = getelementptr inbounds i8, i8* %0, i32 4
+  %3 = load ptr, ptr %2, align 4
-  %4 = bitcast i8* %3 to i8**
+  call void @"main.closureFunctionGoroutine$1"(i32 %1, ptr %3)
-  %5 = load i8*, i8** %4, align 4
+  call void @runtime.deadlock(ptr undef) #8
-  call void @"main.closureFunctionGoroutine$1"(i32 %2, i8* %5)
-  call void @runtime.deadlock(i8* undef) #8
   unreachable
 }
 
-declare void @runtime.printint32(i32, i8*) #0
+declare void @runtime.printint32(i32, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.funcGoroutine(i8* %fn.context, void ()* %fn.funcptr, i8* %context) unnamed_addr #1 {
+define hidden void @main.funcGoroutine(ptr %fn.context, ptr %fn.funcptr, ptr %context) unnamed_addr #1 {
 entry:
-  %0 = call i8* @runtime.alloc(i32 12, i8* null, i8* undef) #8
+  %stackalloc = alloca i8, align 1
-  call void @runtime.trackPointer(i8* nonnull %0, i8* undef) #8
+  %0 = call ptr @runtime.alloc(i32 12, ptr null, ptr undef) #8
-  %1 = bitcast i8* %0 to i32*
+  call void @runtime.trackPointer(ptr nonnull %0, ptr nonnull %stackalloc, ptr undef) #8
-  store i32 5, i32* %1, align 4
+  store i32 5, ptr %0, align 4
-  %2 = getelementptr inbounds i8, i8* %0, i32 4
+  %1 = getelementptr inbounds { i32, ptr, ptr }, ptr %0, i32 0, i32 1
-  %3 = bitcast i8* %2 to i8**
+  store ptr %fn.context, ptr %1, align 4
-  store i8* %fn.context, i8** %3, align 4
+  %2 = getelementptr inbounds { i32, ptr, ptr }, ptr %0, i32 0, i32 2
-  %4 = getelementptr inbounds i8, i8* %0, i32 8
+  store ptr %fn.funcptr, ptr %2, align 4
-  %5 = bitcast i8* %4 to void ()**
+  call void @"internal/task.start"(i32 ptrtoint (ptr @main.funcGoroutine.gowrapper to i32), ptr nonnull %0, i32 16384, ptr undef) #8
-  store void ()* %fn.funcptr, void ()** %5, align 4
-  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @main.funcGoroutine.gowrapper to i32), i8* nonnull %0, i32 16384, i8* undef) #8
   ret void
 }
 
 ; Function Attrs: nounwind
-define linkonce_odr void @main.funcGoroutine.gowrapper(i8* %0) unnamed_addr #5 {
+define linkonce_odr void @main.funcGoroutine.gowrapper(ptr %0) unnamed_addr #5 {
 entry:
-  %1 = bitcast i8* %0 to i32*
+  %1 = load i32, ptr %0, align 4
-  %2 = load i32, i32* %1, align 4
+  %2 = getelementptr inbounds { i32, ptr, ptr }, ptr %0, i32 0, i32 1
-  %3 = getelementptr inbounds i8, i8* %0, i32 4
+  %3 = load ptr, ptr %2, align 4
-  %4 = bitcast i8* %3 to i8**
+  %4 = getelementptr inbounds { i32, ptr, ptr }, ptr %0, i32 0, i32 2
-  %5 = load i8*, i8** %4, align 4
+  %5 = load ptr, ptr %4, align 4
-  %6 = getelementptr inbounds i8, i8* %0, i32 8
+  call void %5(i32 %1, ptr %3) #8
-  %7 = bitcast i8* %6 to void (i32, i8*)**
+  call void @runtime.deadlock(ptr undef) #8
-  %8 = load void (i32, i8*)*, void (i32, i8*)** %7, align 4
-  call void %8(i32 %2, i8* %5) #8
-  call void @runtime.deadlock(i8* undef) #8
   unreachable
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.recoverBuiltinGoroutine(i8* %context) unnamed_addr #1 {
+define hidden void @main.recoverBuiltinGoroutine(ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.copyBuiltinGoroutine(i8* %dst.data, i32 %dst.len, i32 %dst.cap, i8* %src.data, i32 %src.len, i32 %src.cap, i8* %context) unnamed_addr #1 {
+define hidden void @main.copyBuiltinGoroutine(ptr %dst.data, i32 %dst.len, i32 %dst.cap, ptr %src.data, i32 %src.len, i32 %src.cap, ptr %context) unnamed_addr #1 {
 entry:
-  %copy.n = call i32 @runtime.sliceCopy(i8* %dst.data, i8* %src.data, i32 %dst.len, i32 %src.len, i32 1, i8* undef) #8
+  %copy.n = call i32 @runtime.sliceCopy(ptr %dst.data, ptr %src.data, i32 %dst.len, i32 %src.len, i32 1, ptr undef) #8
   ret void
 }
 
-declare i32 @runtime.sliceCopy(i8* nocapture writeonly, i8* nocapture readonly, i32, i32, i32, i8*) #0
+declare i32 @runtime.sliceCopy(ptr nocapture writeonly, ptr nocapture readonly, i32, i32, i32, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.closeBuiltinGoroutine(%runtime.channel* dereferenceable_or_null(32) %ch, i8* %context) unnamed_addr #1 {
+define hidden void @main.closeBuiltinGoroutine(ptr dereferenceable_or_null(32) %ch, ptr %context) unnamed_addr #1 {
 entry:
-  call void @runtime.chanClose(%runtime.channel* %ch, i8* undef) #8
+  call void @runtime.chanClose(ptr %ch, ptr undef) #8
   ret void
 }
 
-declare void @runtime.chanClose(%runtime.channel* dereferenceable_or_null(32), i8*) #0
+declare void @runtime.chanClose(ptr dereferenceable_or_null(32), ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.startInterfaceMethod(i32 %itf.typecode, i8* %itf.value, i8* %context) unnamed_addr #1 {
+define hidden void @main.startInterfaceMethod(i32 %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
 entry:
-  %0 = call i8* @runtime.alloc(i32 16, i8* null, i8* undef) #8
+  %stackalloc = alloca i8, align 1
-  call void @runtime.trackPointer(i8* nonnull %0, i8* undef) #8
+  %0 = call ptr @runtime.alloc(i32 16, ptr null, ptr undef) #8
-  %1 = bitcast i8* %0 to i8**
+  call void @runtime.trackPointer(ptr nonnull %0, ptr nonnull %stackalloc, ptr undef) #8
-  store i8* %itf.value, i8** %1, align 4
+  store ptr %itf.value, ptr %0, align 4
-  %2 = getelementptr inbounds i8, i8* %0, i32 4
+  %1 = getelementptr inbounds { ptr, %runtime._string, i32 }, ptr %0, i32 0, i32 1
-  %.repack = bitcast i8* %2 to i8**
+  store ptr @"main$string", ptr %1, align 4
-  store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @"main$string", i32 0, i32 0), i8** %.repack, align 4
+  %.repack1 = getelementptr inbounds { ptr, %runtime._string, i32 }, ptr %0, i32 0, i32 1, i32 1
-  %.repack1 = getelementptr inbounds i8, i8* %0, i32 8
+  store i32 4, ptr %.repack1, align 4
-  %3 = bitcast i8* %.repack1 to i32*
+  %2 = getelementptr inbounds { ptr, %runtime._string, i32 }, ptr %0, i32 0, i32 2
-  store i32 4, i32* %3, align 4
+  store i32 %itf.typecode, ptr %2, align 4
-  %4 = getelementptr inbounds i8, i8* %0, i32 12
+  call void @"internal/task.start"(i32 ptrtoint (ptr @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper" to i32), ptr nonnull %0, i32 16384, ptr undef) #8
-  %5 = bitcast i8* %4 to i32*
-  store i32 %itf.typecode, i32* %5, align 4
-  call void @"internal/task.start"(i32 ptrtoint (void (i8*)* @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper" to i32), i8* nonnull %0, i32 16384, i8* undef) #8
   ret void
 }
 
-declare void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(i8*, i8*, i32, i32, i8*) #6
+declare void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(ptr, ptr, i32, i32, ptr) #6
 
 ; Function Attrs: nounwind
-define linkonce_odr void @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper"(i8* %0) unnamed_addr #7 {
+define linkonce_odr void @"interface:{Print:func:{basic:string}{}}.Print$invoke$gowrapper"(ptr %0) unnamed_addr #7 {
 entry:
-  %1 = bitcast i8* %0 to i8**
+  %1 = load ptr, ptr %0, align 4
-  %2 = load i8*, i8** %1, align 4
+  %2 = getelementptr inbounds { ptr, ptr, i32, i32 }, ptr %0, i32 0, i32 1
-  %3 = getelementptr inbounds i8, i8* %0, i32 4
+  %3 = load ptr, ptr %2, align 4
-  %4 = bitcast i8* %3 to i8**
+  %4 = getelementptr inbounds { ptr, ptr, i32, i32 }, ptr %0, i32 0, i32 2
-  %5 = load i8*, i8** %4, align 4
+  %5 = load i32, ptr %4, align 4
-  %6 = getelementptr inbounds i8, i8* %0, i32 8
+  %6 = getelementptr inbounds { ptr, ptr, i32, i32 }, ptr %0, i32 0, i32 3
-  %7 = bitcast i8* %6 to i32*
+  %7 = load i32, ptr %6, align 4
-  %8 = load i32, i32* %7, align 4
+  call void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(ptr %1, ptr %3, i32 %5, i32 %7, ptr undef) #8
-  %9 = getelementptr inbounds i8, i8* %0, i32 12
+  call void @runtime.deadlock(ptr undef) #8
-  %10 = bitcast i8* %9 to i32*
-  %11 = load i32, i32* %10, align 4
-  call void @"interface:{Print:func:{basic:string}{}}.Print$invoke"(i8* %2, i8* %5, i32 %8, i32 %11, i8* undef) #8
-  call void @runtime.deadlock(i8* undef) #8
   unreachable
 }
 

compiler/testdata/interface.ll

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

compiler/testdata/pointer.ll

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

compiler/testdata/pragma.ll

@@ -6,16 +6,17 @@ target triple = "wasm32-unknown-wasi"
 @extern_global = external global [0 x i8], align 1
 @main.alignedGlobal = hidden global [4 x i32] zeroinitializer, align 32
 @main.alignedGlobal16 = hidden global [4 x i32] zeroinitializer, align 16
+@llvm.used = appending global [2 x ptr] [ptr @extern_func, ptr @exportedFunctionInSection]
 @main.globalInSection = hidden global i32 0, section ".special_global_section", align 4
 @undefinedGlobalNotInSection = external global i32, align 4
 @main.multipleGlobalPragmas = hidden global i32 0, section ".global_section", align 1024
 
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*) #0
+declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #0
 
-declare void @runtime.trackPointer(i8* nocapture readonly, i8*) #0
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.init(i8* %context) unnamed_addr #1 {
+define hidden void @main.init(ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
@@ -27,27 +28,27 @@ entry:
 }
 
 ; Function Attrs: nounwind
-define hidden void @somepkg.someFunction1(i8* %context) unnamed_addr #1 {
+define hidden void @somepkg.someFunction1(ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
 
-declare void @somepkg.someFunction2(i8*) #0
+declare void @somepkg.someFunction2(ptr) #0
 
 ; Function Attrs: inlinehint nounwind
-define hidden void @main.inlineFunc(i8* %context) unnamed_addr #3 {
+define hidden void @main.inlineFunc(ptr %context) unnamed_addr #3 {
 entry:
   ret void
 }
 
 ; Function Attrs: noinline nounwind
-define hidden void @main.noinlineFunc(i8* %context) unnamed_addr #4 {
+define hidden void @main.noinlineFunc(ptr %context) unnamed_addr #4 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden void @main.functionInSection(i8* %context) unnamed_addr #1 section ".special_function_section" {
+define hidden void @main.functionInSection(ptr %context) unnamed_addr #1 section ".special_function_section" {
 entry:
   ret void
 }
@@ -58,7 +59,7 @@ entry:
   ret void
 }
 
-declare void @main.undefinedFunctionNotInSection(i8*) #0
+declare void @main.undefinedFunctionNotInSection(ptr) #0
 
 attributes #0 = { "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }
 attributes #1 = { nounwind "target-features"="+bulk-memory,+nontrapping-fptoint,+sign-ext" }

compiler/testdata/slice.ll

@@ -3,286 +3,282 @@ source_filename = "slice.go"
 target datalayout = "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-n32:64-S128-ni:1:10:20"
 target triple = "wasm32-unknown-wasi"
 
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*) #0
+declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #0
 
-declare void @runtime.trackPointer(i8* nocapture readonly, i8*) #0
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.init(i8* %context) unnamed_addr #1 {
+define hidden void @main.init(ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.sliceLen(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i8* %context) unnamed_addr #1 {
+define hidden i32 @main.sliceLen(ptr %ints.data, i32 %ints.len, i32 %ints.cap, ptr %context) unnamed_addr #1 {
 entry:
   ret i32 %ints.len
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.sliceCap(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i8* %context) unnamed_addr #1 {
+define hidden i32 @main.sliceCap(ptr %ints.data, i32 %ints.len, i32 %ints.cap, ptr %context) unnamed_addr #1 {
 entry:
   ret i32 %ints.cap
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.sliceElement(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i32 %index, i8* %context) unnamed_addr #1 {
+define hidden i32 @main.sliceElement(ptr %ints.data, i32 %ints.len, i32 %ints.cap, i32 %index, ptr %context) unnamed_addr #1 {
 entry:
   %.not = icmp ult i32 %index, %ints.len
   br i1 %.not, label %lookup.next, label %lookup.throw
 
 lookup.next:                                      ; preds = %entry
-  %0 = getelementptr inbounds i32, i32* %ints.data, i32 %index
+  %0 = getelementptr inbounds i32, ptr %ints.data, i32 %index
-  %1 = load i32, i32* %0, align 4
+  %1 = load i32, ptr %0, align 4
   ret i32 %1
 
 lookup.throw:                                     ; preds = %entry
-  call void @runtime.lookupPanic(i8* undef) #2
+  call void @runtime.lookupPanic(ptr undef) #2
   unreachable
 }
 
-declare void @runtime.lookupPanic(i8*) #0
+declare void @runtime.lookupPanic(ptr) #0
 
 ; Function Attrs: nounwind
-define hidden { i32*, i32, i32 } @main.sliceAppendValues(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i8* %context) unnamed_addr #1 {
+define hidden { ptr, i32, i32 } @main.sliceAppendValues(ptr %ints.data, i32 %ints.len, i32 %ints.cap, ptr %context) unnamed_addr #1 {
 entry:
-  %varargs = call i8* @runtime.alloc(i32 12, i8* nonnull inttoptr (i32 3 to i8*), i8* undef) #2
+  %stackalloc = alloca i8, align 1
-  call void @runtime.trackPointer(i8* nonnull %varargs, i8* undef) #2
+  %varargs = call ptr @runtime.alloc(i32 12, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #2
-  %0 = bitcast i8* %varargs to i32*
+  call void @runtime.trackPointer(ptr nonnull %varargs, ptr nonnull %stackalloc, ptr undef) #2
-  store i32 1, i32* %0, align 4
+  store i32 1, ptr %varargs, align 4
-  %1 = getelementptr inbounds i8, i8* %varargs, i32 4
+  %0 = getelementptr inbounds [3 x i32], ptr %varargs, i32 0, i32 1
-  %2 = bitcast i8* %1 to i32*
+  store i32 2, ptr %0, align 4
-  store i32 2, i32* %2, align 4
+  %1 = getelementptr inbounds [3 x i32], ptr %varargs, i32 0, i32 2
-  %3 = getelementptr inbounds i8, i8* %varargs, i32 8
+  store i32 3, ptr %1, align 4
-  %4 = bitcast i8* %3 to i32*
+  %append.new = call { ptr, i32, i32 } @runtime.sliceAppend(ptr %ints.data, ptr nonnull %varargs, i32 %ints.len, i32 %ints.cap, i32 3, i32 4, ptr undef) #2
-  store i32 3, i32* %4, align 4
+  %append.newPtr = extractvalue { ptr, i32, i32 } %append.new, 0
-  %append.srcPtr = bitcast i32* %ints.data to i8*
+  %append.newLen = extractvalue { ptr, i32, i32 } %append.new, 1
-  %append.new = call { i8*, i32, i32 } @runtime.sliceAppend(i8* %append.srcPtr, i8* nonnull %varargs, i32 %ints.len, i32 %ints.cap, i32 3, i32 4, i8* undef) #2
+  %append.newCap = extractvalue { ptr, i32, i32 } %append.new, 2
-  %append.newPtr = extractvalue { i8*, i32, i32 } %append.new, 0
+  %2 = insertvalue { ptr, i32, i32 } undef, ptr %append.newPtr, 0
-  %append.newBuf = bitcast i8* %append.newPtr to i32*
+  %3 = insertvalue { ptr, i32, i32 } %2, i32 %append.newLen, 1
-  %append.newLen = extractvalue { i8*, i32, i32 } %append.new, 1
+  %4 = insertvalue { ptr, i32, i32 } %3, i32 %append.newCap, 2
-  %append.newCap = extractvalue { i8*, i32, i32 } %append.new, 2
+  call void @runtime.trackPointer(ptr %append.newPtr, ptr nonnull %stackalloc, ptr undef) #2
-  %5 = insertvalue { i32*, i32, i32 } undef, i32* %append.newBuf, 0
+  ret { ptr, i32, i32 } %4
-  %6 = insertvalue { i32*, i32, i32 } %5, i32 %append.newLen, 1
-  %7 = insertvalue { i32*, i32, i32 } %6, i32 %append.newCap, 2
-  call void @runtime.trackPointer(i8* %append.newPtr, i8* undef) #2
-  ret { i32*, i32, i32 } %7
 }
 
-declare { i8*, i32, i32 } @runtime.sliceAppend(i8*, i8* nocapture readonly, i32, i32, i32, i32, i8*) #0
+declare { ptr, i32, i32 } @runtime.sliceAppend(ptr, ptr nocapture readonly, i32, i32, i32, i32, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden { i32*, i32, i32 } @main.sliceAppendSlice(i32* %ints.data, i32 %ints.len, i32 %ints.cap, i32* %added.data, i32 %added.len, i32 %added.cap, i8* %context) unnamed_addr #1 {
+define hidden { ptr, i32, i32 } @main.sliceAppendSlice(ptr %ints.data, i32 %ints.len, i32 %ints.cap, ptr %added.data, i32 %added.len, i32 %added.cap, ptr %context) unnamed_addr #1 {
 entry:
-  %append.srcPtr = bitcast i32* %ints.data to i8*
+  %stackalloc = alloca i8, align 1
-  %append.srcPtr1 = bitcast i32* %added.data to i8*
+  %append.new = call { ptr, i32, i32 } @runtime.sliceAppend(ptr %ints.data, ptr %added.data, i32 %ints.len, i32 %ints.cap, i32 %added.len, i32 4, ptr undef) #2
-  %append.new = call { i8*, i32, i32 } @runtime.sliceAppend(i8* %append.srcPtr, i8* %append.srcPtr1, i32 %ints.len, i32 %ints.cap, i32 %added.len, i32 4, i8* undef) #2
+  %append.newPtr = extractvalue { ptr, i32, i32 } %append.new, 0
-  %append.newPtr = extractvalue { i8*, i32, i32 } %append.new, 0
+  %append.newLen = extractvalue { ptr, i32, i32 } %append.new, 1
-  %append.newBuf = bitcast i8* %append.newPtr to i32*
+  %append.newCap = extractvalue { ptr, i32, i32 } %append.new, 2
-  %append.newLen = extractvalue { i8*, i32, i32 } %append.new, 1
+  %0 = insertvalue { ptr, i32, i32 } undef, ptr %append.newPtr, 0
-  %append.newCap = extractvalue { i8*, i32, i32 } %append.new, 2
+  %1 = insertvalue { ptr, i32, i32 } %0, i32 %append.newLen, 1
-  %0 = insertvalue { i32*, i32, i32 } undef, i32* %append.newBuf, 0
+  %2 = insertvalue { ptr, i32, i32 } %1, i32 %append.newCap, 2
-  %1 = insertvalue { i32*, i32, i32 } %0, i32 %append.newLen, 1
+  call void @runtime.trackPointer(ptr %append.newPtr, ptr nonnull %stackalloc, ptr undef) #2
-  %2 = insertvalue { i32*, i32, i32 } %1, i32 %append.newCap, 2
+  ret { ptr, i32, i32 } %2
-  call void @runtime.trackPointer(i8* %append.newPtr, i8* undef) #2
-  ret { i32*, i32, i32 } %2
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.sliceCopy(i32* %dst.data, i32 %dst.len, i32 %dst.cap, i32* %src.data, i32 %src.len, i32 %src.cap, i8* %context) unnamed_addr #1 {
+define hidden i32 @main.sliceCopy(ptr %dst.data, i32 %dst.len, i32 %dst.cap, ptr %src.data, i32 %src.len, i32 %src.cap, ptr %context) unnamed_addr #1 {
 entry:
-  %copy.dstPtr = bitcast i32* %dst.data to i8*
+  %copy.n = call i32 @runtime.sliceCopy(ptr %dst.data, ptr %src.data, i32 %dst.len, i32 %src.len, i32 4, ptr undef) #2
-  %copy.srcPtr = bitcast i32* %src.data to i8*
-  %copy.n = call i32 @runtime.sliceCopy(i8* %copy.dstPtr, i8* %copy.srcPtr, i32 %dst.len, i32 %src.len, i32 4, i8* undef) #2
   ret i32 %copy.n
 }
 
-declare i32 @runtime.sliceCopy(i8* nocapture writeonly, i8* nocapture readonly, i32, i32, i32, i8*) #0
+declare i32 @runtime.sliceCopy(ptr nocapture writeonly, ptr nocapture readonly, i32, i32, i32, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden { i8*, i32, i32 } @main.makeByteSlice(i32 %len, i8* %context) unnamed_addr #1 {
+define hidden { ptr, i32, i32 } @main.makeByteSlice(i32 %len, ptr %context) unnamed_addr #1 {
 entry:
+  %stackalloc = alloca i8, align 1
   %slice.maxcap = icmp slt i32 %len, 0
   br i1 %slice.maxcap, label %slice.throw, label %slice.next
 
 slice.next:                                       ; preds = %entry
-  %makeslice.buf = call i8* @runtime.alloc(i32 %len, i8* nonnull inttoptr (i32 3 to i8*), i8* undef) #2
+  %makeslice.buf = call ptr @runtime.alloc(i32 %len, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #2
-  %0 = insertvalue { i8*, i32, i32 } undef, i8* %makeslice.buf, 0
+  %0 = insertvalue { ptr, i32, i32 } undef, ptr %makeslice.buf, 0
-  %1 = insertvalue { i8*, i32, i32 } %0, i32 %len, 1
+  %1 = insertvalue { ptr, i32, i32 } %0, i32 %len, 1
-  %2 = insertvalue { i8*, i32, i32 } %1, i32 %len, 2
+  %2 = insertvalue { ptr, i32, i32 } %1, i32 %len, 2
-  call void @runtime.trackPointer(i8* nonnull %makeslice.buf, i8* undef) #2
+  call void @runtime.trackPointer(ptr nonnull %makeslice.buf, ptr nonnull %stackalloc, ptr undef) #2
-  ret { i8*, i32, i32 } %2
+  ret { ptr, i32, i32 } %2
 
 slice.throw:                                      ; preds = %entry
-  call void @runtime.slicePanic(i8* undef) #2
+  call void @runtime.slicePanic(ptr undef) #2
   unreachable
 }
 
-declare void @runtime.slicePanic(i8*) #0
+declare void @runtime.slicePanic(ptr) #0
 
 ; Function Attrs: nounwind
-define hidden { i16*, i32, i32 } @main.makeInt16Slice(i32 %len, i8* %context) unnamed_addr #1 {
+define hidden { ptr, i32, i32 } @main.makeInt16Slice(i32 %len, ptr %context) unnamed_addr #1 {
 entry:
+  %stackalloc = alloca i8, align 1
   %slice.maxcap = icmp slt i32 %len, 0
   br i1 %slice.maxcap, label %slice.throw, label %slice.next
 
 slice.next:                                       ; preds = %entry
   %makeslice.cap = shl i32 %len, 1
-  %makeslice.buf = call i8* @runtime.alloc(i32 %makeslice.cap, i8* nonnull inttoptr (i32 3 to i8*), i8* undef) #2
+  %makeslice.buf = call ptr @runtime.alloc(i32 %makeslice.cap, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #2
-  %makeslice.array = bitcast i8* %makeslice.buf to i16*
+  %0 = insertvalue { ptr, i32, i32 } undef, ptr %makeslice.buf, 0
-  %0 = insertvalue { i16*, i32, i32 } undef, i16* %makeslice.array, 0
+  %1 = insertvalue { ptr, i32, i32 } %0, i32 %len, 1
-  %1 = insertvalue { i16*, i32, i32 } %0, i32 %len, 1
+  %2 = insertvalue { ptr, i32, i32 } %1, i32 %len, 2
-  %2 = insertvalue { i16*, i32, i32 } %1, i32 %len, 2
+  call void @runtime.trackPointer(ptr nonnull %makeslice.buf, ptr nonnull %stackalloc, ptr undef) #2
-  call void @runtime.trackPointer(i8* nonnull %makeslice.buf, i8* undef) #2
+  ret { ptr, i32, i32 } %2
-  ret { i16*, i32, i32 } %2
 
 slice.throw:                                      ; preds = %entry
-  call void @runtime.slicePanic(i8* undef) #2
+  call void @runtime.slicePanic(ptr undef) #2
   unreachable
 }
 
 ; Function Attrs: nounwind
-define hidden { [3 x i8]*, i32, i32 } @main.makeArraySlice(i32 %len, i8* %context) unnamed_addr #1 {
+define hidden { ptr, i32, i32 } @main.makeArraySlice(i32 %len, ptr %context) unnamed_addr #1 {
 entry:
+  %stackalloc = alloca i8, align 1
   %slice.maxcap = icmp ugt i32 %len, 1431655765
   br i1 %slice.maxcap, label %slice.throw, label %slice.next
 
 slice.next:                                       ; preds = %entry
   %makeslice.cap = mul i32 %len, 3
-  %makeslice.buf = call i8* @runtime.alloc(i32 %makeslice.cap, i8* nonnull inttoptr (i32 3 to i8*), i8* undef) #2
+  %makeslice.buf = call ptr @runtime.alloc(i32 %makeslice.cap, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #2
-  %makeslice.array = bitcast i8* %makeslice.buf to [3 x i8]*
+  %0 = insertvalue { ptr, i32, i32 } undef, ptr %makeslice.buf, 0
-  %0 = insertvalue { [3 x i8]*, i32, i32 } undef, [3 x i8]* %makeslice.array, 0
+  %1 = insertvalue { ptr, i32, i32 } %0, i32 %len, 1
-  %1 = insertvalue { [3 x i8]*, i32, i32 } %0, i32 %len, 1
+  %2 = insertvalue { ptr, i32, i32 } %1, i32 %len, 2
-  %2 = insertvalue { [3 x i8]*, i32, i32 } %1, i32 %len, 2
+  call void @runtime.trackPointer(ptr nonnull %makeslice.buf, ptr nonnull %stackalloc, ptr undef) #2
-  call void @runtime.trackPointer(i8* nonnull %makeslice.buf, i8* undef) #2
+  ret { ptr, i32, i32 } %2
-  ret { [3 x i8]*, i32, i32 } %2
 
 slice.throw:                                      ; preds = %entry
-  call void @runtime.slicePanic(i8* undef) #2
+  call void @runtime.slicePanic(ptr undef) #2
   unreachable
 }
 
 ; Function Attrs: nounwind
-define hidden { i32*, i32, i32 } @main.makeInt32Slice(i32 %len, i8* %context) unnamed_addr #1 {
+define hidden { ptr, i32, i32 } @main.makeInt32Slice(i32 %len, ptr %context) unnamed_addr #1 {
 entry:
+  %stackalloc = alloca i8, align 1
   %slice.maxcap = icmp ugt i32 %len, 1073741823
   br i1 %slice.maxcap, label %slice.throw, label %slice.next
 
 slice.next:                                       ; preds = %entry
   %makeslice.cap = shl i32 %len, 2
-  %makeslice.buf = call i8* @runtime.alloc(i32 %makeslice.cap, i8* nonnull inttoptr (i32 3 to i8*), i8* undef) #2
+  %makeslice.buf = call ptr @runtime.alloc(i32 %makeslice.cap, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #2
-  %makeslice.array = bitcast i8* %makeslice.buf to i32*
+  %0 = insertvalue { ptr, i32, i32 } undef, ptr %makeslice.buf, 0
-  %0 = insertvalue { i32*, i32, i32 } undef, i32* %makeslice.array, 0
+  %1 = insertvalue { ptr, i32, i32 } %0, i32 %len, 1
-  %1 = insertvalue { i32*, i32, i32 } %0, i32 %len, 1
+  %2 = insertvalue { ptr, i32, i32 } %1, i32 %len, 2
-  %2 = insertvalue { i32*, i32, i32 } %1, i32 %len, 2
+  call void @runtime.trackPointer(ptr nonnull %makeslice.buf, ptr nonnull %stackalloc, ptr undef) #2
-  call void @runtime.trackPointer(i8* nonnull %makeslice.buf, i8* undef) #2
+  ret { ptr, i32, i32 } %2
-  ret { i32*, i32, i32 } %2
 
 slice.throw:                                      ; preds = %entry
-  call void @runtime.slicePanic(i8* undef) #2
+  call void @runtime.slicePanic(ptr undef) #2
   unreachable
 }
 
 ; Function Attrs: nounwind
-define hidden i8* @main.Add32(i8* %p, i32 %len, i8* %context) unnamed_addr #1 {
+define hidden ptr @main.Add32(ptr %p, i32 %len, ptr %context) unnamed_addr #1 {
 entry:
-  %0 = getelementptr i8, i8* %p, i32 %len
+  %stackalloc = alloca i8, align 1
-  call void @runtime.trackPointer(i8* %0, i8* undef) #2
+  %0 = getelementptr i8, ptr %p, i32 %len
-  ret i8* %0
+  call void @runtime.trackPointer(ptr %0, ptr nonnull %stackalloc, ptr undef) #2
+  ret ptr %0
 }
 
 ; Function Attrs: nounwind
-define hidden i8* @main.Add64(i8* %p, i64 %len, i8* %context) unnamed_addr #1 {
+define hidden ptr @main.Add64(ptr %p, i64 %len, ptr %context) unnamed_addr #1 {
 entry:
+  %stackalloc = alloca i8, align 1
   %0 = trunc i64 %len to i32
-  %1 = getelementptr i8, i8* %p, i32 %0
+  %1 = getelementptr i8, ptr %p, i32 %0
-  call void @runtime.trackPointer(i8* %1, i8* undef) #2
+  call void @runtime.trackPointer(ptr %1, ptr nonnull %stackalloc, ptr undef) #2
-  ret i8* %1
+  ret ptr %1
 }
 
 ; Function Attrs: nounwind
-define hidden [4 x i32]* @main.SliceToArray(i32* %s.data, i32 %s.len, i32 %s.cap, i8* %context) unnamed_addr #1 {
+define hidden ptr @main.SliceToArray(ptr %s.data, i32 %s.len, i32 %s.cap, ptr %context) unnamed_addr #1 {
 entry:
   %0 = icmp ult i32 %s.len, 4
   br i1 %0, label %slicetoarray.throw, label %slicetoarray.next
 
 slicetoarray.next:                                ; preds = %entry
-  %1 = bitcast i32* %s.data to [4 x i32]*
+  ret ptr %s.data
-  ret [4 x i32]* %1
 
 slicetoarray.throw:                               ; preds = %entry
-  call void @runtime.sliceToArrayPointerPanic(i8* undef) #2
+  call void @runtime.sliceToArrayPointerPanic(ptr undef) #2
   unreachable
 }
 
-declare void @runtime.sliceToArrayPointerPanic(i8*) #0
+declare void @runtime.sliceToArrayPointerPanic(ptr) #0
 
 ; Function Attrs: nounwind
-define hidden [4 x i32]* @main.SliceToArrayConst(i8* %context) unnamed_addr #1 {
+define hidden ptr @main.SliceToArrayConst(ptr %context) unnamed_addr #1 {
 entry:
-  %makeslice = call i8* @runtime.alloc(i32 24, i8* nonnull inttoptr (i32 3 to i8*), i8* undef) #2
+  %stackalloc = alloca i8, align 1
-  call void @runtime.trackPointer(i8* nonnull %makeslice, i8* undef) #2
+  %makeslice = call ptr @runtime.alloc(i32 24, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #2
+  call void @runtime.trackPointer(ptr nonnull %makeslice, ptr nonnull %stackalloc, ptr undef) #2
   br i1 false, label %slicetoarray.throw, label %slicetoarray.next
 
 slicetoarray.next:                                ; preds = %entry
-  %0 = bitcast i8* %makeslice to [4 x i32]*
+  ret ptr %makeslice
-  ret [4 x i32]* %0
 
 slicetoarray.throw:                               ; preds = %entry
   unreachable
 }
 
 ; Function Attrs: nounwind
-define hidden { i32*, i32, i32 } @main.SliceInt(i32* dereferenceable_or_null(4) %ptr, i32 %len, i8* %context) unnamed_addr #1 {
+define hidden { ptr, i32, i32 } @main.SliceInt(ptr dereferenceable_or_null(4) %ptr, i32 %len, ptr %context) unnamed_addr #1 {
 entry:
+  %stackalloc = alloca i8, align 1
   %0 = icmp ugt i32 %len, 1073741823
-  %1 = icmp eq i32* %ptr, null
+  %1 = icmp eq ptr %ptr, null
   %2 = icmp ne i32 %len, 0
   %3 = and i1 %1, %2
   %4 = or i1 %3, %0
   br i1 %4, label %unsafe.Slice.throw, label %unsafe.Slice.next
 
 unsafe.Slice.next:                                ; preds = %entry
-  %5 = insertvalue { i32*, i32, i32 } undef, i32* %ptr, 0
+  %5 = insertvalue { ptr, i32, i32 } undef, ptr %ptr, 0
-  %6 = insertvalue { i32*, i32, i32 } %5, i32 %len, 1
+  %6 = insertvalue { ptr, i32, i32 } %5, i32 %len, 1
-  %7 = insertvalue { i32*, i32, i32 } %6, i32 %len, 2
+  %7 = insertvalue { ptr, i32, i32 } %6, i32 %len, 2
-  %8 = bitcast i32* %ptr to i8*
+  call void @runtime.trackPointer(ptr %ptr, ptr nonnull %stackalloc, ptr undef) #2
-  call void @runtime.trackPointer(i8* %8, i8* undef) #2
+  ret { ptr, i32, i32 } %7
-  ret { i32*, i32, i32 } %7
 
 unsafe.Slice.throw:                               ; preds = %entry
-  call void @runtime.unsafeSlicePanic(i8* undef) #2
+  call void @runtime.unsafeSlicePanic(ptr undef) #2
   unreachable
 }
 
-declare void @runtime.unsafeSlicePanic(i8*) #0
+declare void @runtime.unsafeSlicePanic(ptr) #0
 
 ; Function Attrs: nounwind
-define hidden { i8*, i32, i32 } @main.SliceUint16(i8* dereferenceable_or_null(1) %ptr, i16 %len, i8* %context) unnamed_addr #1 {
+define hidden { ptr, i32, i32 } @main.SliceUint16(ptr dereferenceable_or_null(1) %ptr, i16 %len, ptr %context) unnamed_addr #1 {
 entry:
-  %0 = icmp eq i8* %ptr, null
+  %stackalloc = alloca i8, align 1
+  %0 = icmp eq ptr %ptr, null
   %1 = icmp ne i16 %len, 0
   %2 = and i1 %0, %1
   br i1 %2, label %unsafe.Slice.throw, label %unsafe.Slice.next
 
 unsafe.Slice.next:                                ; preds = %entry
   %3 = zext i16 %len to i32
-  %4 = insertvalue { i8*, i32, i32 } undef, i8* %ptr, 0
+  %4 = insertvalue { ptr, i32, i32 } undef, ptr %ptr, 0
-  %5 = insertvalue { i8*, i32, i32 } %4, i32 %3, 1
+  %5 = insertvalue { ptr, i32, i32 } %4, i32 %3, 1
-  %6 = insertvalue { i8*, i32, i32 } %5, i32 %3, 2
+  %6 = insertvalue { ptr, i32, i32 } %5, i32 %3, 2
-  call void @runtime.trackPointer(i8* %ptr, i8* undef) #2
+  call void @runtime.trackPointer(ptr %ptr, ptr nonnull %stackalloc, ptr undef) #2
-  ret { i8*, i32, i32 } %6
+  ret { ptr, i32, i32 } %6
 
 unsafe.Slice.throw:                               ; preds = %entry
-  call void @runtime.unsafeSlicePanic(i8* undef) #2
+  call void @runtime.unsafeSlicePanic(ptr undef) #2
   unreachable
 }
 
 ; Function Attrs: nounwind
-define hidden { i32*, i32, i32 } @main.SliceUint64(i32* dereferenceable_or_null(4) %ptr, i64 %len, i8* %context) unnamed_addr #1 {
+define hidden { ptr, i32, i32 } @main.SliceUint64(ptr dereferenceable_or_null(4) %ptr, i64 %len, ptr %context) unnamed_addr #1 {
 entry:
+  %stackalloc = alloca i8, align 1
   %0 = icmp ugt i64 %len, 1073741823
-  %1 = icmp eq i32* %ptr, null
+  %1 = icmp eq ptr %ptr, null
   %2 = icmp ne i64 %len, 0
   %3 = and i1 %1, %2
   %4 = or i1 %3, %0
@@ -290,23 +286,23 @@ entry:
 
 unsafe.Slice.next:                                ; preds = %entry
   %5 = trunc i64 %len to i32
-  %6 = insertvalue { i32*, i32, i32 } undef, i32* %ptr, 0
+  %6 = insertvalue { ptr, i32, i32 } undef, ptr %ptr, 0
-  %7 = insertvalue { i32*, i32, i32 } %6, i32 %5, 1
+  %7 = insertvalue { ptr, i32, i32 } %6, i32 %5, 1
-  %8 = insertvalue { i32*, i32, i32 } %7, i32 %5, 2
+  %8 = insertvalue { ptr, i32, i32 } %7, i32 %5, 2
-  %9 = bitcast i32* %ptr to i8*
+  call void @runtime.trackPointer(ptr %ptr, ptr nonnull %stackalloc, ptr undef) #2
-  call void @runtime.trackPointer(i8* %9, i8* undef) #2
+  ret { ptr, i32, i32 } %8
-  ret { i32*, i32, i32 } %8
 
 unsafe.Slice.throw:                               ; preds = %entry
-  call void @runtime.unsafeSlicePanic(i8* undef) #2
+  call void @runtime.unsafeSlicePanic(ptr undef) #2
   unreachable
 }
 
 ; Function Attrs: nounwind
-define hidden { i32*, i32, i32 } @main.SliceInt64(i32* dereferenceable_or_null(4) %ptr, i64 %len, i8* %context) unnamed_addr #1 {
+define hidden { ptr, i32, i32 } @main.SliceInt64(ptr dereferenceable_or_null(4) %ptr, i64 %len, ptr %context) unnamed_addr #1 {
 entry:
+  %stackalloc = alloca i8, align 1
   %0 = icmp ugt i64 %len, 1073741823
-  %1 = icmp eq i32* %ptr, null
+  %1 = icmp eq ptr %ptr, null
   %2 = icmp ne i64 %len, 0
   %3 = and i1 %1, %2
   %4 = or i1 %3, %0
@@ -314,15 +310,14 @@ entry:
 
 unsafe.Slice.next:                                ; preds = %entry
   %5 = trunc i64 %len to i32
-  %6 = insertvalue { i32*, i32, i32 } undef, i32* %ptr, 0
+  %6 = insertvalue { ptr, i32, i32 } undef, ptr %ptr, 0
-  %7 = insertvalue { i32*, i32, i32 } %6, i32 %5, 1
+  %7 = insertvalue { ptr, i32, i32 } %6, i32 %5, 1
-  %8 = insertvalue { i32*, i32, i32 } %7, i32 %5, 2
+  %8 = insertvalue { ptr, i32, i32 } %7, i32 %5, 2
-  %9 = bitcast i32* %ptr to i8*
+  call void @runtime.trackPointer(ptr %ptr, ptr nonnull %stackalloc, ptr undef) #2
-  call void @runtime.trackPointer(i8* %9, i8* undef) #2
+  ret { ptr, i32, i32 } %8
-  ret { i32*, i32, i32 } %8
 
 unsafe.Slice.throw:                               ; preds = %entry
-  call void @runtime.unsafeSlicePanic(i8* undef) #2
+  call void @runtime.unsafeSlicePanic(ptr undef) #2
   unreachable
 }
 

compiler/testdata/string.ll

@@ -3,96 +3,96 @@ source_filename = "string.go"
 target datalayout = "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-n32:64-S128-ni:1:10:20"
 target triple = "wasm32-unknown-wasi"
 
-%runtime._string = type { i8*, i32 }
+%runtime._string = type { ptr, i32 }
 
 @"main$string" = internal unnamed_addr constant [3 x i8] c"foo", align 1
 
-declare noalias nonnull i8* @runtime.alloc(i32, i8*, i8*) #0
+declare noalias nonnull ptr @runtime.alloc(i32, ptr, ptr) #0
 
-declare void @runtime.trackPointer(i8* nocapture readonly, i8*) #0
+declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden void @main.init(i8* %context) unnamed_addr #1 {
+define hidden void @main.init(ptr %context) unnamed_addr #1 {
 entry:
   ret void
 }
 
 ; Function Attrs: nounwind
-define hidden %runtime._string @main.someString(i8* %context) unnamed_addr #1 {
+define hidden %runtime._string @main.someString(ptr %context) unnamed_addr #1 {
 entry:
-  ret %runtime._string { i8* getelementptr inbounds ([3 x i8], [3 x i8]* @"main$string", i32 0, i32 0), i32 3 }
+  ret %runtime._string { ptr @"main$string", i32 3 }
 }
 
 ; Function Attrs: nounwind
-define hidden %runtime._string @main.zeroLengthString(i8* %context) unnamed_addr #1 {
+define hidden %runtime._string @main.zeroLengthString(ptr %context) unnamed_addr #1 {
 entry:
   ret %runtime._string zeroinitializer
 }
 
 ; Function Attrs: nounwind
-define hidden i32 @main.stringLen(i8* %s.data, i32 %s.len, i8* %context) unnamed_addr #1 {
+define hidden i32 @main.stringLen(ptr %s.data, i32 %s.len, ptr %context) unnamed_addr #1 {
 entry:
   ret i32 %s.len
 }
 
 ; Function Attrs: nounwind
-define hidden i8 @main.stringIndex(i8* %s.data, i32 %s.len, i32 %index, i8* %context) unnamed_addr #1 {
+define hidden i8 @main.stringIndex(ptr %s.data, i32 %s.len, i32 %index, ptr %context) unnamed_addr #1 {
 entry:
   %.not = icmp ult i32 %index, %s.len
   br i1 %.not, label %lookup.next, label %lookup.throw
 
 lookup.next:                                      ; preds = %entry
-  %0 = getelementptr inbounds i8, i8* %s.data, i32 %index
+  %0 = getelementptr inbounds i8, ptr %s.data, i32 %index
-  %1 = load i8, i8* %0, align 1
+  %1 = load i8, ptr %0, align 1
   ret i8 %1
 
 lookup.throw:                                     ; preds = %entry
-  call void @runtime.lookupPanic(i8* undef) #2
+  call void @runtime.lookupPanic(ptr undef) #2
   unreachable
 }
 
-declare void @runtime.lookupPanic(i8*) #0
+declare void @runtime.lookupPanic(ptr) #0
 
 ; Function Attrs: nounwind
-define hidden i1 @main.stringCompareEqual(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* %context) unnamed_addr #1 {
+define hidden i1 @main.stringCompareEqual(ptr %s1.data, i32 %s1.len, ptr %s2.data, i32 %s2.len, ptr %context) unnamed_addr #1 {
 entry:
-  %0 = call i1 @runtime.stringEqual(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* undef) #2
+  %0 = call i1 @runtime.stringEqual(ptr %s1.data, i32 %s1.len, ptr %s2.data, i32 %s2.len, ptr undef) #2
   ret i1 %0
 }
 
-declare i1 @runtime.stringEqual(i8*, i32, i8*, i32, i8*) #0
+declare i1 @runtime.stringEqual(ptr, i32, ptr, i32, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden i1 @main.stringCompareUnequal(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* %context) unnamed_addr #1 {
+define hidden i1 @main.stringCompareUnequal(ptr %s1.data, i32 %s1.len, ptr %s2.data, i32 %s2.len, ptr %context) unnamed_addr #1 {
 entry:
-  %0 = call i1 @runtime.stringEqual(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* undef) #2
+  %0 = call i1 @runtime.stringEqual(ptr %s1.data, i32 %s1.len, ptr %s2.data, i32 %s2.len, ptr undef) #2
   %1 = xor i1 %0, true
   ret i1 %1
 }
 
 ; Function Attrs: nounwind
-define hidden i1 @main.stringCompareLarger(i8* %s1.data, i32 %s1.len, i8* %s2.data, i32 %s2.len, i8* %context) unnamed_addr #1 {
+define hidden i1 @main.stringCompareLarger(ptr %s1.data, i32 %s1.len, ptr %s2.data, i32 %s2.len, ptr %context) unnamed_addr #1 {
 entry:
-  %0 = call i1 @runtime.stringLess(i8* %s2.data, i32 %s2.len, i8* %s1.data, i32 %s1.len, i8* undef) #2
+  %0 = call i1 @runtime.stringLess(ptr %s2.data, i32 %s2.len, ptr %s1.data, i32 %s1.len, ptr undef) #2
   ret i1 %0
 }
 
-declare i1 @runtime.stringLess(i8*, i32, i8*, i32, i8*) #0
+declare i1 @runtime.stringLess(ptr, i32, ptr, i32, ptr) #0
 
 ; Function Attrs: nounwind
-define hidden i8 @main.stringLookup(i8* %s.data, i32 %s.len, i8 %x, i8* %context) unnamed_addr #1 {
+define hidden i8 @main.stringLookup(ptr %s.data, i32 %s.len, i8 %x, ptr %context) unnamed_addr #1 {
 entry:
   %0 = zext i8 %x to i32
   %.not = icmp ult i32 %0, %s.len
   br i1 %.not, label %lookup.next, label %lookup.throw
 
 lookup.next:                                      ; preds = %entry
-  %1 = getelementptr inbounds i8, i8* %s.data, i32 %0
+  %1 = getelementptr inbounds i8, ptr %s.data, i32 %0
-  %2 = load i8, i8* %1, align 1
+  %2 = load i8, ptr %1, align 1
   ret i8 %2
 
 lookup.throw:                                     ; preds = %entry
-  call void @runtime.lookupPanic(i8* undef) #2
+  call void @runtime.lookupPanic(ptr undef) #2
   unreachable
 }
 

compiler/volatile.go

@@ -1,5 +1,7 @@
 package compiler
 
+import "go/types"
+
 // This file implements volatile loads/stores in runtime/volatile.LoadT and
 // runtime/volatile.StoreT as compiler builtins.
 
@@ -9,7 +11,8 @@ func (b *builder) createVolatileLoad() {
 	b.createFunctionStart(true)
 	addr := b.getValue(b.fn.Params[0])
 	b.createNilCheck(b.fn.Params[0], addr, "deref")
-	val := b.CreateLoad(addr, "")
+	valType := b.getLLVMType(b.fn.Params[0].Type().(*types.Pointer).Elem())
+	val := b.CreateLoad(valType, addr, "")
 	val.SetVolatile(true)
 	b.CreateRet(val)
 }

go.mod

@@ -14,10 +14,10 @@ require (
 	github.com/mattn/go-colorable v0.1.8
 	github.com/mattn/go-tty v0.0.4
 	go.bug.st/serial v1.3.5
-	golang.org/x/sys v0.0.0-20220829200755-d48e67d00261
+	golang.org/x/sys v0.4.0
-	golang.org/x/tools v0.1.11
+	golang.org/x/tools v0.5.0
 	gopkg.in/yaml.v2 v2.4.0
-	tinygo.org/x/go-llvm v0.0.0-20220802112859-5bb0b77907a7
+	tinygo.org/x/go-llvm v0.0.0-20221028183034-8341240c0b32
 )
 
 require (
@@ -29,5 +29,4 @@ require (
 	github.com/josharian/intern v1.0.0 // indirect
 	github.com/mailru/easyjson v0.7.7 // indirect
 	github.com/mattn/go-isatty v0.0.12 // indirect
-	golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4 // indirect
 )

go.sum

@@ -46,8 +46,7 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb
 github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
 go.bug.st/serial v1.3.5 h1:k50SqGZCnHZ2MiBQgzccXWG+kd/XpOs1jUljpDDKzaE=
 go.bug.st/serial v1.3.5/go.mod h1:z8CesKorE90Qr/oRSJiEuvzYRKol9r/anJZEb5kt304=
-golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4 h1:6zppjxzCulZykYSLyVDYbneBfbaBIQPYMevg0bEwv2s=
+golang.org/x/mod v0.7.0 h1:LapD9S96VoQRhi/GrNTqeBJFrUjs5UHCAtTlgwA5oZA=
-golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
 golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20191008105621-543471e840be/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -55,14 +54,14 @@ golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201207223542-d4d67f95c62d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20211124211545-fe61309f8881/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220829200755-d48e67d00261 h1:v6hYoSR9T5oet+pMXwUWkbiVqx/63mlHjefrHmxwfeY=
+golang.org/x/sys v0.4.0 h1:Zr2JFtRQNX3BCZ8YtxRE9hNJYC8J6I1MVbMg6owUp18=
-golang.org/x/sys v0.0.0-20220829200755-d48e67d00261/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.4.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/tools v0.1.11 h1:loJ25fNOEhSXfHrpoGj91eCUThwdNX6u24rO1xnNteY=
+golang.org/x/tools v0.5.0 h1:+bSpV5HIeWkuvgaMfI3UmKRThoTA5ODJTUd8T17NO+4=
-golang.org/x/tools v0.1.11/go.mod h1:SgwaegtQh8clINPpECJMqnxLv9I09HLqnW3RMqW0CA4=
+golang.org/x/tools v0.5.0/go.mod h1:N+Kgy78s5I24c24dU8OfWNEotWjutIs8SnJvn5IDq+k=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
 gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
-tinygo.org/x/go-llvm v0.0.0-20220802112859-5bb0b77907a7 h1:nSLR52mUw7DPQQVA3ZJFH63zjU4ME84fKiin6mdnYWc=
+tinygo.org/x/go-llvm v0.0.0-20221028183034-8341240c0b32 h1:LvdmoXncO43m2cws1chRB2hkLBAxfN6CbSjDI7+gk4Y=
-tinygo.org/x/go-llvm v0.0.0-20220802112859-5bb0b77907a7/go.mod h1:GFbusT2VTA4I+l4j80b17KFK+6whv69Wtny5U+T8RR0=
+tinygo.org/x/go-llvm v0.0.0-20221028183034-8341240c0b32/go.mod h1:GFbusT2VTA4I+l4j80b17KFK+6whv69Wtny5U+T8RR0=

goenv/version.go

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

interp/compiler.go

@@ -209,7 +209,7 @@ func (r *runner) compileFunction(llvmFn llvm.Value) *function {
 			case llvm.Alloca:
 				// Alloca allocates stack space for local variables.
 				numElements := r.getValue(inst.llvmInst.Operand(0)).(literalValue).value.(uint32)
-				elementSize := r.targetData.TypeAllocSize(inst.llvmInst.Type().ElementType())
+				elementSize := r.targetData.TypeAllocSize(inst.llvmInst.AllocatedType())
 				inst.operands = []value{
 					literalValue{elementSize * uint64(numElements)},
 				}
@@ -218,17 +218,17 @@ func (r *runner) compileFunction(llvmFn llvm.Value) *function {
 				inst.name = llvmInst.Name()
 				ptr := llvmInst.Operand(0)
 				n := llvmInst.OperandsCount()
-				elementType := ptr.Type().ElementType()
+				elementType := llvmInst.GEPSourceElementType()
 				// gep: [source ptr, dest value size, pairs of indices...]
 				inst.operands = []value{
 					r.getValue(ptr),
-					literalValue{r.targetData.TypeAllocSize(llvmInst.Type().ElementType())},
 					r.getValue(llvmInst.Operand(1)),
 					literalValue{r.targetData.TypeAllocSize(elementType)},
 				}
 				for i := 2; i < n; i++ {
 					operand := r.getValue(llvmInst.Operand(i))
-					if elementType.TypeKind() == llvm.StructTypeKind {
+					switch elementType.TypeKind() {
+					case llvm.StructTypeKind:
 						index := operand.(literalValue).value.(uint32)
 						elementOffset := r.targetData.ElementOffset(elementType, int(index))
 						// Encode operands in a special way. The elementOffset
@@ -242,12 +242,15 @@ func (r *runner) compileFunction(llvmFn llvm.Value) *function {
 						// runtime.
 						inst.operands = append(inst.operands, literalValue{elementOffset}, literalValue{^uint64(index)})
 						elementType = elementType.StructElementTypes()[index]
-					} else {
+					case llvm.ArrayTypeKind:
 						elementType = elementType.ElementType()
 						elementSize := r.targetData.TypeAllocSize(elementType)
 						elementSizeOperand := literalValue{elementSize}
 						// Add operand * elementSizeOperand bytes to the pointer.
 						inst.operands = append(inst.operands, operand, elementSizeOperand)
+					default:
+						// This should be unreachable.
+						panic("unknown type: " + elementType.String())
 					}
 				}
 			case llvm.BitCast, llvm.IntToPtr, llvm.PtrToInt:
@@ -267,10 +270,12 @@ func (r *runner) compileFunction(llvmFn llvm.Value) *function {
 					case llvm.StructTypeKind:
 						offset += r.targetData.ElementOffset(indexingType, int(index))
 						indexingType = indexingType.StructElementTypes()[index]
-					default: // ArrayTypeKind
+					case llvm.ArrayTypeKind:
 						indexingType = indexingType.ElementType()
 						elementSize := r.targetData.TypeAllocSize(indexingType)
 						offset += elementSize * uint64(index)
+					default:
+						panic("unknown type kind") // unreachable
 					}
 				}
 				size := r.targetData.TypeAllocSize(inst.llvmInst.Type())
@@ -290,10 +295,12 @@ func (r *runner) compileFunction(llvmFn llvm.Value) *function {
 					case llvm.StructTypeKind:
 						offset += r.targetData.ElementOffset(indexingType, int(index))
 						indexingType = indexingType.StructElementTypes()[index]
-					default: // ArrayTypeKind
+					case llvm.ArrayTypeKind:
 						indexingType = indexingType.ElementType()
 						elementSize := r.targetData.TypeAllocSize(indexingType)
 						offset += elementSize * uint64(index)
+					default:
+						panic("unknown type kind") // unreachable
 					}
 				}
 				// insertvalue [agg, elt, byteOffset]

interp/interp.go

@@ -127,7 +127,7 @@ func Run(mod llvm.Module, timeout time.Duration, debug bool) error {
 				// Create a call to the package initializer (which was
 				// previously deleted).
 				i8undef := llvm.Undef(r.i8ptrType)
-				r.builder.CreateCall(fn, []llvm.Value{i8undef}, "")
+				r.builder.CreateCall(fn.GlobalValueType(), fn, []llvm.Value{i8undef}, "")
 				// Make sure that any globals touched by the package
 				// initializer, won't be accessed by later package initializers.
 				err := r.markExternalLoad(fn)
@@ -156,7 +156,7 @@ func Run(mod llvm.Module, timeout time.Duration, debug bool) error {
 		if obj.constant {
 			continue // constant buffers can't have been modified
 		}
-		initializer, err := obj.buffer.toLLVMValue(obj.llvmGlobal.Type().ElementType(), &mem)
+		initializer, err := obj.buffer.toLLVMValue(obj.llvmGlobal.GlobalValueType(), &mem)
 		if err == errInvalidPtrToIntSize {
 			// This can happen when a previous interp run did not have the
 			// correct LLVM type for a global and made something up. In that
@@ -190,7 +190,7 @@ func Run(mod llvm.Module, timeout time.Duration, debug bool) error {
 		if err != nil {
 			return err
 		}
-		if checks && initializer.Type() != obj.llvmGlobal.Type().ElementType() {
+		if checks && initializer.Type() != obj.llvmGlobal.GlobalValueType() {
 			panic("initializer type mismatch")
 		}
 		obj.llvmGlobal.SetInitializer(initializer)
@@ -213,7 +213,7 @@ func RunFunc(fn llvm.Value, timeout time.Duration, debug bool) error {
 	r.pkgName = initName[:len(initName)-len(".init")]
 
 	// Create new function with the interp result.
-	newFn := llvm.AddFunction(mod, fn.Name()+".tmp", fn.Type().ElementType())
+	newFn := llvm.AddFunction(mod, fn.Name()+".tmp", fn.GlobalValueType())
 	newFn.SetLinkage(fn.Linkage())
 	newFn.SetVisibility(fn.Visibility())
 	entry := mod.Context().AddBasicBlock(newFn, "entry")
@@ -263,11 +263,11 @@ func RunFunc(fn llvm.Value, timeout time.Duration, debug bool) error {
 		if obj.constant {
 			continue // constant, so can't have been modified
 		}
-		initializer, err := obj.buffer.toLLVMValue(obj.llvmGlobal.Type().ElementType(), &mem)
+		initializer, err := obj.buffer.toLLVMValue(obj.llvmGlobal.GlobalValueType(), &mem)
 		if err != nil {
 			return err
 		}
-		if checks && initializer.Type() != obj.llvmGlobal.Type().ElementType() {
+		if checks && initializer.Type() != obj.llvmGlobal.GlobalValueType() {
 			panic("initializer type mismatch")
 		}
 		obj.llvmGlobal.SetInitializer(initializer)

interp/interpreter.go

@@ -356,7 +356,7 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				default:
 					panic("unknown integer type width")
 				}
-			case strings.HasPrefix(callFn.name, "llvm.memcpy.p0i8.p0i8.") || strings.HasPrefix(callFn.name, "llvm.memmove.p0i8.p0i8."):
+			case strings.HasPrefix(callFn.name, "llvm.memcpy.p0") || strings.HasPrefix(callFn.name, "llvm.memmove.p0"):
 				// Copy a block of memory from one pointer to another.
 				dst, err := operands[1].asPointer(r)
 				if err != nil {
@@ -408,7 +408,7 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				// Elem() is only valid for certain type classes.
 				switch class {
 				case "chan", "pointer", "slice", "array":
-					elementType := llvm.ConstExtractValue(typecodeID.Initializer(), []uint32{0})
+					elementType := r.builder.CreateExtractValue(typecodeID.Initializer(), 0, "")
 					uintptrType := r.mod.Context().IntType(int(mem.r.pointerSize) * 8)
 					locals[inst.localIndex] = r.getValue(llvm.ConstPtrToInt(elementType, uintptrType))
 				default:
@@ -461,8 +461,8 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				// easier checking in the next step.
 				concreteTypeMethods := map[string]struct{}{}
 				for i := 0; i < methodSet.Type().ArrayLength(); i++ {
-					methodInfo := llvm.ConstExtractValue(methodSet, []uint32{uint32(i)})
+					methodInfo := r.builder.CreateExtractValue(methodSet, i, "")
-					name := llvm.ConstExtractValue(methodInfo, []uint32{0}).Name()
+					name := r.builder.CreateExtractValue(methodInfo, 0, "").Name()
 					concreteTypeMethods[name] = struct{}{}
 				}
 
@@ -496,7 +496,7 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				typecodeID := typecodeIDBitCast.Operand(0).Initializer()
 
 				// Load the method set, which is part of the typecodeID object.
-				methodSet := llvm.ConstExtractValue(typecodeID, []uint32{2}).Operand(0).Initializer()
+				methodSet := stripPointerCasts(r.builder.CreateExtractValue(typecodeID, 2, "")).Initializer()
 
 				// We don't need to load the interface method set.
 
@@ -511,9 +511,10 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				numMethods := methodSet.Type().ArrayLength()
 				var method llvm.Value
 				for i := 0; i < numMethods; i++ {
-					methodSignature := llvm.ConstExtractValue(methodSet, []uint32{uint32(i), 0})
+					methodSignatureAgg := r.builder.CreateExtractValue(methodSet, i, "")
+					methodSignature := r.builder.CreateExtractValue(methodSignatureAgg, 0, "")
 					if methodSignature == signature {
-						method = llvm.ConstExtractValue(methodSet, []uint32{uint32(i), 1}).Operand(0)
+						method = r.builder.CreateExtractValue(methodSignatureAgg, 1, "").Operand(0)
 					}
 				}
 				if method.IsNil() {
@@ -636,7 +637,7 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 			// Create the new object.
 			size := operands[0].(literalValue).value.(uint64)
 			alloca := object{
-				llvmType:   inst.llvmInst.Type(),
+				llvmType:   inst.llvmInst.AllocatedType(),
 				globalName: r.pkgName + "$alloca",
 				buffer:     newRawValue(uint32(size)),
 				size:       uint32(size),
@@ -654,7 +655,7 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 			// GetElementPtr does pointer arithmetic, changing the offset of the
 			// pointer into the underlying object.
 			var offset uint64
-			for i := 2; i < len(operands); i += 2 {
+			for i := 1; i < len(operands); i += 2 {
 				index := operands[i].Uint()
 				elementSize := operands[i+1].Uint()
 				if int64(elementSize) < 0 {
@@ -722,46 +723,9 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 			locals[inst.localIndex] = newagg
 		case llvm.ICmp:
 			predicate := llvm.IntPredicate(operands[2].(literalValue).value.(uint8))
-			var result bool
 			lhs := operands[0]
 			rhs := operands[1]
-			switch predicate {
+			result := r.interpretICmp(lhs, rhs, predicate)
-			case llvm.IntEQ, llvm.IntNE:
-				lhsPointer, lhsErr := lhs.asPointer(r)
-				rhsPointer, rhsErr := rhs.asPointer(r)
-				if (lhsErr == nil) != (rhsErr == nil) {
-					// Fast path: only one is a pointer, so they can't be equal.
-					result = false
-				} else if lhsErr == nil {
-					// Both must be nil, so both are pointers.
-					// Compare them directly.
-					result = lhsPointer.equal(rhsPointer)
-				} else {
-					// Fall back to generic comparison.
-					result = lhs.asRawValue(r).equal(rhs.asRawValue(r))
-				}
-				if predicate == llvm.IntNE {
-					result = !result
-				}
-			case llvm.IntUGT:
-				result = lhs.Uint() > rhs.Uint()
-			case llvm.IntUGE:
-				result = lhs.Uint() >= rhs.Uint()
-			case llvm.IntULT:
-				result = lhs.Uint() < rhs.Uint()
-			case llvm.IntULE:
-				result = lhs.Uint() <= rhs.Uint()
-			case llvm.IntSGT:
-				result = lhs.Int() > rhs.Int()
-			case llvm.IntSGE:
-				result = lhs.Int() >= rhs.Int()
-			case llvm.IntSLT:
-				result = lhs.Int() < rhs.Int()
-			case llvm.IntSLE:
-				result = lhs.Int() <= rhs.Int()
-			default:
-				return nil, mem, r.errorAt(inst, errors.New("interp: unsupported icmp"))
-			}
 			if result {
 				locals[inst.localIndex] = literalValue{uint8(1)}
 			} else {
@@ -947,6 +911,51 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 	return nil, mem, r.errorAt(bb.instructions[len(bb.instructions)-1], errors.New("interp: reached end of basic block without terminator"))
 }
 
+// Interpret an icmp instruction. Doesn't have side effects, only returns the
+// output of the comparison.
+func (r *runner) interpretICmp(lhs, rhs value, predicate llvm.IntPredicate) bool {
+	switch predicate {
+	case llvm.IntEQ, llvm.IntNE:
+		var result bool
+		lhsPointer, lhsErr := lhs.asPointer(r)
+		rhsPointer, rhsErr := rhs.asPointer(r)
+		if (lhsErr == nil) != (rhsErr == nil) {
+			// Fast path: only one is a pointer, so they can't be equal.
+			result = false
+		} else if lhsErr == nil {
+			// Both must be nil, so both are pointers.
+			// Compare them directly.
+			result = lhsPointer.equal(rhsPointer)
+		} else {
+			// Fall back to generic comparison.
+			result = lhs.asRawValue(r).equal(rhs.asRawValue(r))
+		}
+		if predicate == llvm.IntNE {
+			result = !result
+		}
+		return result
+	case llvm.IntUGT:
+		return lhs.Uint() > rhs.Uint()
+	case llvm.IntUGE:
+		return lhs.Uint() >= rhs.Uint()
+	case llvm.IntULT:
+		return lhs.Uint() < rhs.Uint()
+	case llvm.IntULE:
+		return lhs.Uint() <= rhs.Uint()
+	case llvm.IntSGT:
+		return lhs.Int() > rhs.Int()
+	case llvm.IntSGE:
+		return lhs.Int() >= rhs.Int()
+	case llvm.IntSLT:
+		return lhs.Int() < rhs.Int()
+	case llvm.IntSLE:
+		return lhs.Int() <= rhs.Int()
+	default:
+		// _should_ be unreachable, until LLVM adds new icmp operands (unlikely)
+		panic("interp: unsupported icmp")
+	}
+}
+
 func (r *runner) runAtRuntime(fn *function, inst instruction, locals []value, mem *memoryView, indent string) *Error {
 	numOperands := inst.llvmInst.OperandsCount()
 	operands := make([]llvm.Value, numOperands)
@@ -977,13 +986,13 @@ func (r *runner) runAtRuntime(fn *function, inst instruction, locals []value, me
 				}
 			}
 		}
-		result = r.builder.CreateCall(llvmFn, args, inst.name)
+		result = r.builder.CreateCall(inst.llvmInst.CalledFunctionType(), llvmFn, args, inst.name)
 	case llvm.Load:
 		err := mem.markExternalLoad(operands[0])
 		if err != nil {
 			return r.errorAt(inst, err)
 		}
-		result = r.builder.CreateLoad(operands[0], inst.name)
+		result = r.builder.CreateLoad(inst.llvmInst.Type(), operands[0], inst.name)
 		if inst.llvmInst.IsVolatile() {
 			result.SetVolatile(true)
 		}
@@ -1086,3 +1095,15 @@ func intPredicateString(predicate llvm.IntPredicate) string {
 		return "cmp?"
 	}
 }
+
+// Strip some pointer casts. This is probably unnecessary once support for
+// LLVM 14 (non-opaque pointers) is dropped.
+func stripPointerCasts(value llvm.Value) llvm.Value {
+	if !value.IsAConstantExpr().IsNil() {
+		switch value.Opcode() {
+		case llvm.GetElementPtr, llvm.BitCast:
+			return stripPointerCasts(value.Operand(0))
+		}
+	}
+	return value
+}

interp/memory.go

@@ -37,7 +37,7 @@ import (
 // ability to roll back interpreting a function.
 type object struct {
 	llvmGlobal     llvm.Value
-	llvmType       llvm.Type // must match llvmGlobal.Type() if both are set, may be unset if llvmGlobal is set
+	llvmType       llvm.Type // must match llvmGlobal.GlobalValueType() if both are set, may be unset if llvmGlobal is set
 	llvmLayoutType llvm.Type // LLVM type based on runtime.alloc layout parameter, if available
 	globalName     string    // name, if not yet created (not guaranteed to be the final name)
 	buffer         value     // buffer with value as given by interp, nil if external
@@ -215,7 +215,7 @@ func (mv *memoryView) markExternal(llvmValue llvm.Value, mark uint8) error {
 		case llvm.StructTypeKind:
 			numElements := llvmType.StructElementTypesCount()
 			for i := 0; i < numElements; i++ {
-				element := llvm.ConstExtractValue(llvmValue, []uint32{uint32(i)})
+				element := mv.r.builder.CreateExtractValue(llvmValue, i, "")
 				err := mv.markExternal(element, mark)
 				if err != nil {
 					return err
@@ -224,7 +224,7 @@ func (mv *memoryView) markExternal(llvmValue llvm.Value, mark uint8) error {
 		case llvm.ArrayTypeKind:
 			numElements := llvmType.ArrayLength()
 			for i := 0; i < numElements; i++ {
-				element := llvm.ConstExtractValue(llvmValue, []uint32{uint32(i)})
+				element := mv.r.builder.CreateExtractValue(llvmValue, i, "")
 				err := mv.markExternal(element, mark)
 				if err != nil {
 					return err
@@ -594,7 +594,7 @@ func (v pointerValue) toLLVMValue(llvmType llvm.Type, mem *memoryView) (llvm.Val
 			var globalType llvm.Type
 			if !obj.llvmType.IsNil() {
 				// The exact type is known.
-				globalType = obj.llvmType.ElementType()
+				globalType = obj.llvmType
 			} else { // !obj.llvmLayoutType.IsNil()
 				// The exact type isn't known, but the object layout is known.
 				globalType = obj.llvmLayoutType
@@ -646,8 +646,8 @@ func (v pointerValue) toLLVMValue(llvmType llvm.Type, mem *memoryView) (llvm.Val
 		if llvmValue.Type() != mem.r.i8ptrType {
 			llvmValue = llvm.ConstBitCast(llvmValue, mem.r.i8ptrType)
 		}
-		llvmValue = llvm.ConstInBoundsGEP(llvmValue, []llvm.Value{
+		llvmValue = llvm.ConstInBoundsGEP(mem.r.mod.Context().Int8Type(), llvmValue, []llvm.Value{
-			llvm.ConstInt(llvmValue.Type().Context().Int32Type(), uint64(v.offset()), false),
+			llvm.ConstInt(mem.r.mod.Context().Int32Type(), uint64(v.offset()), false),
 		})
 	}
 
@@ -808,14 +808,17 @@ func (v rawValue) rawLLVMValue(mem *memoryView) (llvm.Value, error) {
 			if err != nil {
 				return llvm.Value{}, err
 			}
-			elementType := field.Type().ElementType()
+			if !field.IsAGlobalVariable().IsNil() {
-			if elementType.TypeKind() == llvm.StructTypeKind {
+				elementType := field.GlobalValueType()
-				// There are some special pointer types that should be used as a
+				if elementType.TypeKind() == llvm.StructTypeKind {
-				// ptrtoint, so that they can be used in certain optimizations.
+					// There are some special pointer types that should be used
-				name := elementType.StructName()
+					// as a ptrtoint, so that they can be used in certain
-				if name == "runtime.typecodeID" || name == "runtime.funcValueWithSignature" {
+					// optimizations.
-					uintptrType := ctx.IntType(int(mem.r.pointerSize) * 8)
+					name := elementType.StructName()
-					field = llvm.ConstPtrToInt(field, uintptrType)
+					if name == "runtime.typecodeID" || name == "runtime.funcValueWithSignature" {
+						uintptrType := ctx.IntType(int(mem.r.pointerSize) * 8)
+						field = llvm.ConstPtrToInt(field, uintptrType)
+					}
 				}
 			}
 			structFields = append(structFields, field)
@@ -998,7 +1001,7 @@ func (v *rawValue) set(llvmValue llvm.Value, r *runner) {
 			ptr := llvmValue.Operand(0)
 			index := llvmValue.Operand(1)
 			numOperands := llvmValue.OperandsCount()
-			elementType := ptr.Type().ElementType()
+			elementType := llvmValue.GEPSourceElementType()
 			totalOffset := r.targetData.TypeAllocSize(elementType) * index.ZExtValue()
 			for i := 2; i < numOperands; i++ {
 				indexValue := llvmValue.Operand(i)
@@ -1028,6 +1031,17 @@ func (v *rawValue) set(llvmValue llvm.Value, r *runner) {
 			for i := uint32(0); i < ptrSize; i++ {
 				v.buf[i] = ptrValue.pointer
 			}
+		case llvm.ICmp:
+			size := r.targetData.TypeAllocSize(llvmValue.Operand(0).Type())
+			lhs := newRawValue(uint32(size))
+			rhs := newRawValue(uint32(size))
+			lhs.set(llvmValue.Operand(0), r)
+			rhs.set(llvmValue.Operand(1), r)
+			if r.interpretICmp(lhs, rhs, llvmValue.IntPredicate()) {
+				v.buf[0] = 1 // result is true
+			} else {
+				v.buf[0] = 0 // result is false
+			}
 		default:
 			llvmValue.Dump()
 			println()
@@ -1074,7 +1088,7 @@ func (v *rawValue) set(llvmValue llvm.Value, r *runner) {
 				field := rawValue{
 					buf: v.buf[offset:],
 				}
-				field.set(llvm.ConstExtractValue(llvmValue, []uint32{uint32(i)}), r)
+				field.set(r.builder.CreateExtractValue(llvmValue, i, ""), r)
 			}
 		case llvm.ArrayTypeKind:
 			numElements := llvmType.ArrayLength()
@@ -1085,7 +1099,7 @@ func (v *rawValue) set(llvmValue llvm.Value, r *runner) {
 				field := rawValue{
 					buf: v.buf[offset:],
 				}
-				field.set(llvm.ConstExtractValue(llvmValue, []uint32{uint32(i)}), r)
+				field.set(r.builder.CreateExtractValue(llvmValue, i, ""), r)
 			}
 		case llvm.DoubleTypeKind:
 			f, _ := llvmValue.DoubleValue()
@@ -1173,7 +1187,7 @@ func (r *runner) getValue(llvmValue llvm.Value) value {
 			r.globals[llvmValue] = index
 			r.objects = append(r.objects, obj)
 			if !llvmValue.IsAGlobalVariable().IsNil() {
-				obj.size = uint32(r.targetData.TypeAllocSize(llvmValue.Type().ElementType()))
+				obj.size = uint32(r.targetData.TypeAllocSize(llvmValue.GlobalValueType()))
 				if initializer := llvmValue.Initializer(); !initializer.IsNil() {
 					obj.buffer = r.getValue(initializer)
 					obj.constant = llvmValue.IsGlobalConstant()
@@ -1222,6 +1236,8 @@ func (r *runner) getValue(llvmValue llvm.Value) value {
 
 // readObjectLayout reads the object layout as it is stored by the compiler. It
 // returns the size in the number of words and the bitmap.
+//
+// For details on this format, see src/runtime/gc_precise.go.
 func (r *runner) readObjectLayout(layoutValue value) (uint64, *big.Int) {
 	pointerSize := layoutValue.len(r)
 	if checks && uint64(pointerSize) != r.targetData.TypeAllocSize(r.i8ptrType) {
@@ -1275,6 +1291,7 @@ func (r *runner) readObjectLayout(layoutValue value) (uint64, *big.Int) {
 		}
 		rawBytes[i] = byte(v)
 	}
+	reverseBytes(rawBytes) // little-endian to big-endian
 	bitmap := new(big.Int).SetBytes(rawBytes)
 	return objectSizeWords, bitmap
 }
@@ -1324,3 +1341,12 @@ func (r *runner) getLLVMTypeFromLayout(layoutValue value) llvm.Type {
 	}
 	return llvmLayoutType
 }
+
+// Reverse a slice of bytes. From the wiki:
+// https://github.com/golang/go/wiki/SliceTricks#reversing
+func reverseBytes(buf []byte) {
+	for i := len(buf)/2 - 1; i >= 0; i-- {
+		opp := len(buf) - 1 - i
+		buf[i], buf[opp] = buf[opp], buf[i]
+	}
+}

interp/testdata/alloc.ll

@@ -1,7 +1,7 @@
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32--wasi"
 
-@"runtime/gc.layout:62-2000000000000001" = linkonce_odr unnamed_addr constant { i32, [8 x i8] } { i32 62, [8 x i8] c" \00\00\00\00\00\00\01" }
+@"runtime/gc.layout:62-2000000000000001" = linkonce_odr unnamed_addr constant { i32, [8 x i8] } { i32 62, [8 x i8] c"\01\00\00\00\00\00\00 " }
 @pointerFree12 = global i8* null
 @pointerFree7 = global i8* null
 @pointerFree3 = global i8* null

interp/testdata/consteval.ll

@@ -3,6 +3,7 @@ target triple = "x86_64--linux"
 
 @intToPtrResult = global i8 0
 @ptrToIntResult = global i8 0
+@icmpResult = global i8 0
 @someArray = internal global {i16, i8, i8} zeroinitializer
 @someArrayPointer = global i8* zeroinitializer
 
@@ -15,6 +16,7 @@ define internal void @main.init() {
   call void @testIntToPtr()
   call void @testPtrToInt()
   call void @testConstGEP()
+  call void @testICmp()
   ret void
 }
 
@@ -48,3 +50,16 @@ define internal void @testConstGEP() {
   store i8* getelementptr inbounds (i8, i8* bitcast ({i16, i8, i8}* @someArray to i8*), i32 2), i8** @someArrayPointer
   ret void
 }
+
+define internal void @testICmp() {
+  br i1 icmp eq (i64 ptrtoint (i8* @ptrToIntResult to i64), i64 0), label %equal, label %unequal
+equal:
+  ; should not be reached
+  store i8 1, i8* @icmpResult
+  ret void
+unequal:
+  ; should be reached
+  store i8 2, i8* @icmpResult
+  ret void
+  ret void
+}

interp/testdata/consteval.out.ll

@@ -3,6 +3,7 @@ target triple = "x86_64--linux"
 
 @intToPtrResult = local_unnamed_addr global i8 2
 @ptrToIntResult = local_unnamed_addr global i8 2
+@icmpResult = local_unnamed_addr global i8 2
 @someArray = internal global { i16, i8, i8 } zeroinitializer
 @someArrayPointer = local_unnamed_addr global i8* getelementptr inbounds ({ i16, i8, i8 }, { i16, i8, i8 }* @someArray, i64 0, i32 1)
 

main.go

@@ -155,7 +155,27 @@ func Build(pkgName, outpath string, options *compileopts.Options) error {
 		return nil
 	}
 
-	return builder.Build(pkgName, outpath, config, func(result builder.BuildResult) error {
+	// Create a temporary directory for intermediary files.
+	tmpdir, err := os.MkdirTemp("", "tinygo")
+	if err != nil {
+		return err
+	}
+	if !options.Work {
+		defer os.RemoveAll(tmpdir)
+	}
+
+	// Do the build.
+	result, err := builder.Build(pkgName, outpath, tmpdir, config)
+	if err != nil {
+		return err
+	}
+
+	if result.Binary != "" {
+		// If result.Binary is set, it means there is a build output (elf, hex,
+		// etc) that we need to move to the outpath. If it isn't set, it means
+		// the build output was a .ll, .bc or .o file that has already been
+		// written to outpath and so we don't need to do anything.
+
 		if outpath == "" {
 			if strings.HasSuffix(pkgName, ".go") {
 				// A Go file was specified directly on the command line.
@@ -187,11 +207,11 @@ func Build(pkgName, outpath string, options *compileopts.Options) error {
 
 			// Check whether file writing was successful.
 			return outf.Close()
-		} else {
-			// Move was successful.
-			return nil
 		}
-	})
+	}
+
+	// Move was successful.
+	return nil
 }
 
 // Test runs the tests in the given package. Returns whether the test passed and
@@ -224,8 +244,10 @@ func Test(pkgName string, stdout, stderr io.Writer, options *compileopts.Options
 		flags = append(flags, "-test.benchmem")
 	}
 
+	buf := bytes.Buffer{}
 	passed := false
-	err = buildAndRun(pkgName, config, os.Stdout, flags, nil, 0, func(cmd *exec.Cmd, result builder.BuildResult) error {
+	var duration time.Duration
+	result, err := buildAndRun(pkgName, config, &buf, flags, nil, 0, func(cmd *exec.Cmd, result builder.BuildResult) error {
 		if testCompileOnly || outpath != "" {
 			// Write test binary to the specified file name.
 			if outpath == "" {
@@ -264,24 +286,13 @@ func Test(pkgName string, stdout, stderr io.Writer, options *compileopts.Options
 			// relative directory up to the module root, even if the test never
 			// reads any files.
 			//
-			// Ex. --dir=.. --dir=../.. --dir=../../..
+			// Ex. run --dir=.. --dir=../.. --dir=../../..
 			dirs := dirsToModuleRoot(result.MainDir, result.ModuleRoot)
-			var args []string
+			args := []string{"run"}
 			for _, d := range dirs[1:] {
 				args = append(args, "--dir="+d)
 			}
 
-			// Some tests create temp directories using os.MkdirTemp or via
-			// t.TempDir(). Create a writeable directory and map it to the
-			// default tempDir environment variable: TMPDIR.
-			tmpdir, err := os.MkdirTemp("", "tinygotmp")
-			if err != nil {
-				return fmt.Errorf("failed to create temporary directory: %w", err)
-			}
-			args = append(args, "--dir="+tmpdir, "--env=TMPDIR="+tmpdir)
-			// TODO: add option to not delete temp dir for debugging?
-			defer os.RemoveAll(tmpdir)
-
 			// The below re-organizes the arguments so that the current
 			// directory is added last.
 			args = append(args, cmd.Args[1:]...)
@@ -291,27 +302,34 @@ func Test(pkgName string, stdout, stderr io.Writer, options *compileopts.Options
 		// Run the test.
 		start := time.Now()
 		err = cmd.Run()
-		duration := time.Since(start)
+		duration = time.Since(start)
-
-		// Print the result.
-		importPath := strings.TrimSuffix(result.ImportPath, ".test")
 		passed = err == nil
-		if passed {
+
-			fmt.Fprintf(stdout, "ok  \t%s\t%.3fs\n", importPath, duration.Seconds())
+		// print the test output if
-		} else {
+		// 1) the tests passed and in verbose mode
-			fmt.Fprintf(stdout, "FAIL\t%s\t%.3fs\n", importPath, duration.Seconds())
+		// 2) the tests failed
+		// 3) running benchmarks
+		if (passed && testVerbose) || (!passed) || (testBenchRegexp != "") {
+			buf.WriteTo(stdout)
 		}
+
 		if _, ok := err.(*exec.ExitError); ok {
 			// Binary exited with a non-zero exit code, which means the test
-			// failed.
+			// failed. Return nil to avoid printing a useless "exited with
+			// error" error message.
 			return nil
 		}
 		return err
 	})
+	importPath := strings.TrimSuffix(result.ImportPath, ".test")
 	if err, ok := err.(loader.NoTestFilesError); ok {
 		fmt.Fprintf(stdout, "?   \t%s\t[no test files]\n", err.ImportPath)
 		// Pretend the test passed - it at least didn't fail.
 		return true, nil
+	} else if passed {
+		fmt.Fprintf(stdout, "ok  \t%s\t%.3fs\n", importPath, duration.Seconds())
+	} else {
+		fmt.Fprintf(stdout, "FAIL\t%s\t%.3fs\n", importPath, duration.Seconds())
 	}
 	return passed, err
 }
@@ -371,116 +389,130 @@ func Flash(pkgName, port string, options *compileopts.Options) error {
 		return errors.New("unknown flash method: " + flashMethod)
 	}
 
-	return builder.Build(pkgName, fileExt, config, func(result builder.BuildResult) error {
+	// Create a temporary directory for intermediary files.
-		// do we need port reset to put MCU into bootloader mode?
+	tmpdir, err := os.MkdirTemp("", "tinygo")
-		if config.Target.PortReset == "true" && flashMethod != "openocd" {
+	if err != nil {
-			port, err := getDefaultPort(port, config.Target.SerialPort)
+		return err
-			if err == nil {
+	}
-				err = touchSerialPortAt1200bps(port)
+	if !options.Work {
-				if err != nil {
+		defer os.RemoveAll(tmpdir)
-					return &commandError{"failed to reset port", result.Binary, err}
+	}
-				}
+
-				// give the target MCU a chance to restart into bootloader
+	// Build the binary.
-				time.Sleep(3 * time.Second)
+	result, err := builder.Build(pkgName, fileExt, tmpdir, config)
+	if err != nil {
+		return err
+	}
+
+	// do we need port reset to put MCU into bootloader mode?
+	if config.Target.PortReset == "true" && flashMethod != "openocd" {
+		port, err := getDefaultPort(port, config.Target.SerialPort)
+		if err == nil {
+			err = touchSerialPortAt1200bps(port)
+			if err != nil {
+				return &commandError{"failed to reset port", port, err}
+			}
+			// give the target MCU a chance to restart into bootloader
+			time.Sleep(3 * time.Second)
+		}
+	}
+
+	// Flash the binary to the MCU.
+	switch flashMethod {
+	case "", "command":
+		// Create the command.
+		flashCmd := config.Target.FlashCommand
+		flashCmdList, err := shlex.Split(flashCmd)
+		if err != nil {
+			return fmt.Errorf("could not parse flash command %#v: %w", flashCmd, err)
+		}
+
+		if strings.Contains(flashCmd, "{port}") {
+			var err error
+			port, err = getDefaultPort(port, config.Target.SerialPort)
+			if err != nil {
+				return err
 			}
 		}
 
+		// Fill in fields in the command template.
+		fileToken := "{" + fileExt[1:] + "}"
+		for i, arg := range flashCmdList {
+			arg = strings.ReplaceAll(arg, fileToken, result.Binary)
+			arg = strings.ReplaceAll(arg, "{port}", port)
+			flashCmdList[i] = arg
+		}
+
+		// Execute the command.
+		if len(flashCmdList) < 2 {
+			return fmt.Errorf("invalid flash command: %#v", flashCmd)
+		}
+		cmd := executeCommand(config.Options, flashCmdList[0], flashCmdList[1:]...)
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		cmd.Dir = goenv.Get("TINYGOROOT")
+		err = cmd.Run()
+		if err != nil {
+			return &commandError{"failed to flash", result.Binary, err}
+		}
+	case "msd":
 		// this flashing method copies the binary data to a Mass Storage Device (msd)
-		switch flashMethod {
+		switch fileExt {
-		case "", "command":
+		case ".uf2":
-			// Create the command.
+			err := flashUF2UsingMSD(config.Target.FlashVolume, result.Binary, config.Options)
-			flashCmd := config.Target.FlashCommand
-			flashCmdList, err := shlex.Split(flashCmd)
-			if err != nil {
-				return fmt.Errorf("could not parse flash command %#v: %w", flashCmd, err)
-			}
-
-			if strings.Contains(flashCmd, "{port}") {
-				var err error
-				port, err = getDefaultPort(port, config.Target.SerialPort)
-				if err != nil {
-					return err
-				}
-			}
-
-			// Fill in fields in the command template.
-			fileToken := "{" + fileExt[1:] + "}"
-			for i, arg := range flashCmdList {
-				arg = strings.ReplaceAll(arg, fileToken, result.Binary)
-				arg = strings.ReplaceAll(arg, "{port}", port)
-				flashCmdList[i] = arg
-			}
-
-			// Execute the command.
-			if len(flashCmdList) < 2 {
-				return fmt.Errorf("invalid flash command: %#v", flashCmd)
-			}
-			cmd := executeCommand(config.Options, flashCmdList[0], flashCmdList[1:]...)
-			cmd.Stdout = os.Stdout
-			cmd.Stderr = os.Stderr
-			cmd.Dir = goenv.Get("TINYGOROOT")
-			err = cmd.Run()
 			if err != nil {
 				return &commandError{"failed to flash", result.Binary, err}
 			}
-		case "msd":
+		case ".hex":
-			switch fileExt {
+			err := flashHexUsingMSD(config.Target.FlashVolume, result.Binary, config.Options)
-			case ".uf2":
-				err := flashUF2UsingMSD(config.Target.FlashVolume, result.Binary, config.Options)
-				if err != nil {
-					return &commandError{"failed to flash", result.Binary, err}
-				}
-			case ".hex":
-				err := flashHexUsingMSD(config.Target.FlashVolume, result.Binary, config.Options)
-				if err != nil {
-					return &commandError{"failed to flash", result.Binary, err}
-				}
-			default:
-				return errors.New("mass storage device flashing currently only supports uf2 and hex")
-			}
-		case "openocd":
-			args, err := config.OpenOCDConfiguration()
-			if err != nil {
-				return err
-			}
-			exit := " reset exit"
-			if config.Target.OpenOCDVerify != nil && *config.Target.OpenOCDVerify {
-				exit = " verify" + exit
-			}
-			args = append(args, "-c", "program "+filepath.ToSlash(result.Binary)+exit)
-			cmd := executeCommand(config.Options, "openocd", args...)
-			cmd.Stdout = os.Stdout
-			cmd.Stderr = os.Stderr
-			err = cmd.Run()
-			if err != nil {
-				return &commandError{"failed to flash", result.Binary, err}
-			}
-		case "bmp":
-			gdb, err := config.Target.LookupGDB()
-			if err != nil {
-				return err
-			}
-			var bmpGDBPort string
-			bmpGDBPort, _, err = getBMPPorts()
-			if err != nil {
-				return err
-			}
-			args := []string{"-ex", "target extended-remote " + bmpGDBPort, "-ex", "monitor swdp_scan", "-ex", "attach 1", "-ex", "load", filepath.ToSlash(result.Binary)}
-			cmd := executeCommand(config.Options, gdb, args...)
-			cmd.Stdout = os.Stdout
-			cmd.Stderr = os.Stderr
-			err = cmd.Run()
 			if err != nil {
 				return &commandError{"failed to flash", result.Binary, err}
 			}
 		default:
-			return fmt.Errorf("unknown flash method: %s", flashMethod)
+			return errors.New("mass storage device flashing currently only supports uf2 and hex")
 		}
-		if options.Monitor {
+	case "openocd":
-			return Monitor("", options)
+		args, err := config.OpenOCDConfiguration()
+		if err != nil {
+			return err
 		}
-		return nil
+		exit := " reset exit"
-	})
+		if config.Target.OpenOCDVerify != nil && *config.Target.OpenOCDVerify {
+			exit = " verify" + exit
+		}
+		args = append(args, "-c", "program "+filepath.ToSlash(result.Binary)+exit)
+		cmd := executeCommand(config.Options, "openocd", args...)
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		err = cmd.Run()
+		if err != nil {
+			return &commandError{"failed to flash", result.Binary, err}
+		}
+	case "bmp":
+		gdb, err := config.Target.LookupGDB()
+		if err != nil {
+			return err
+		}
+		var bmpGDBPort string
+		bmpGDBPort, _, err = getBMPPorts()
+		if err != nil {
+			return err
+		}
+		args := []string{"-ex", "target extended-remote " + bmpGDBPort, "-ex", "monitor swdp_scan", "-ex", "attach 1", "-ex", "load", filepath.ToSlash(result.Binary)}
+		cmd := executeCommand(config.Options, gdb, args...)
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		err = cmd.Run()
+		if err != nil {
+			return &commandError{"failed to flash", result.Binary, err}
+		}
+	default:
+		return fmt.Errorf("unknown flash method: %s", flashMethod)
+	}
+	if options.Monitor {
+		return Monitor("", options)
+	}
+	return nil
 }
 
 // Debug compiles and flashes a program to a microcontroller (just like Flash)
@@ -506,195 +538,208 @@ func Debug(debugger, pkgName string, ocdOutput bool, options *compileopts.Option
 		return err
 	}
 
-	format, fileExt := config.EmulatorFormat()
+	// Create a temporary directory for intermediary files.
-	return builder.Build(pkgName, fileExt, config, func(result builder.BuildResult) error {
+	tmpdir, err := os.MkdirTemp("", "tinygo")
-		// Find a good way to run GDB.
+	if err != nil {
-		gdbInterface, openocdInterface := config.Programmer()
+		return err
-		switch gdbInterface {
+	}
-		case "msd", "command", "":
+	if !options.Work {
-			emulator := config.EmulatorName()
+		defer os.RemoveAll(tmpdir)
-			if emulator != "" {
+	}
-				if emulator == "mgba" {
-					gdbInterface = "mgba"
-				} else if emulator == "simavr" {
-					gdbInterface = "simavr"
-				} else if strings.HasPrefix(emulator, "qemu-system-") {
-					gdbInterface = "qemu"
-				} else {
-					// Assume QEMU as an emulator.
-					gdbInterface = "qemu-user"
-				}
-			} else if openocdInterface != "" && config.Target.OpenOCDTarget != "" {
-				gdbInterface = "openocd"
-			} else if config.Target.JLinkDevice != "" {
-				gdbInterface = "jlink"
-			} else {
-				gdbInterface = "native"
-			}
-		}
 
-		// Run the GDB server, if necessary.
+	// Build the binary to debug.
-		port := ""
+	format, fileExt := config.EmulatorFormat()
-		var gdbCommands []string
+	result, err := builder.Build(pkgName, fileExt, tmpdir, config)
-		var daemon *exec.Cmd
+	if err != nil {
-		emulator, err := config.Emulator(format, result.Binary)
+		return err
+	}
+
+	// Find a good way to run GDB.
+	gdbInterface, openocdInterface := config.Programmer()
+	switch gdbInterface {
+	case "msd", "command", "":
+		emulator := config.EmulatorName()
+		if emulator != "" {
+			if emulator == "mgba" {
+				gdbInterface = "mgba"
+			} else if emulator == "simavr" {
+				gdbInterface = "simavr"
+			} else if strings.HasPrefix(emulator, "qemu-system-") {
+				gdbInterface = "qemu"
+			} else {
+				// Assume QEMU as an emulator.
+				gdbInterface = "qemu-user"
+			}
+		} else if openocdInterface != "" && config.Target.OpenOCDTarget != "" {
+			gdbInterface = "openocd"
+		} else if config.Target.JLinkDevice != "" {
+			gdbInterface = "jlink"
+		} else {
+			gdbInterface = "native"
+		}
+	}
+
+	// Run the GDB server, if necessary.
+	port := ""
+	var gdbCommands []string
+	var daemon *exec.Cmd
+	emulator, err := config.Emulator(format, result.Binary)
+	if err != nil {
+		return err
+	}
+	switch gdbInterface {
+	case "native":
+		// Run GDB directly.
+	case "bmp":
+		var bmpGDBPort string
+		bmpGDBPort, _, err = getBMPPorts()
 		if err != nil {
 			return err
 		}
-		switch gdbInterface {
+		port = bmpGDBPort
-		case "native":
+		gdbCommands = append(gdbCommands, "monitor swdp_scan", "compare-sections", "attach 1", "load")
-			// Run GDB directly.
+	case "openocd":
-		case "bmp":
+		port = ":3333"
-			var bmpGDBPort string
+		gdbCommands = append(gdbCommands, "monitor halt", "load", "monitor reset halt")
-			bmpGDBPort, _, err = getBMPPorts()
-			if err != nil {
-				return err
-			}
-			port = bmpGDBPort
-			gdbCommands = append(gdbCommands, "monitor swdp_scan", "compare-sections", "attach 1", "load")
-		case "openocd":
-			port = ":3333"
-			gdbCommands = append(gdbCommands, "monitor halt", "load", "monitor reset halt")
 
-			// We need a separate debugging daemon for on-chip debugging.
+		// We need a separate debugging daemon for on-chip debugging.
-			args, err := config.OpenOCDConfiguration()
+		args, err := config.OpenOCDConfiguration()
-			if err != nil {
-				return err
-			}
-			daemon = executeCommand(config.Options, "openocd", args...)
-			if ocdOutput {
-				// Make it clear which output is from the daemon.
-				w := &ColorWriter{
-					Out:    colorable.NewColorableStderr(),
-					Prefix: "openocd: ",
-					Color:  TermColorYellow,
-				}
-				daemon.Stdout = w
-				daemon.Stderr = w
-			}
-		case "jlink":
-			port = ":2331"
-			gdbCommands = append(gdbCommands, "load", "monitor reset halt")
-
-			// We need a separate debugging daemon for on-chip debugging.
-			daemon = executeCommand(config.Options, "JLinkGDBServer", "-device", config.Target.JLinkDevice)
-			if ocdOutput {
-				// Make it clear which output is from the daemon.
-				w := &ColorWriter{
-					Out:    colorable.NewColorableStderr(),
-					Prefix: "jlink: ",
-					Color:  TermColorYellow,
-				}
-				daemon.Stdout = w
-				daemon.Stderr = w
-			}
-		case "qemu":
-			port = ":1234"
-			// Run in an emulator.
-			args := append(emulator[1:], "-s", "-S")
-			daemon = executeCommand(config.Options, emulator[0], args...)
-			daemon.Stdout = os.Stdout
-			daemon.Stderr = os.Stderr
-		case "qemu-user":
-			port = ":1234"
-			// Run in an emulator.
-			args := append(emulator[1:], "-g", "1234")
-			daemon = executeCommand(config.Options, emulator[0], args...)
-			daemon.Stdout = os.Stdout
-			daemon.Stderr = os.Stderr
-		case "mgba":
-			port = ":2345"
-			// Run in an emulator.
-			args := append(emulator[1:], "-g")
-			daemon = executeCommand(config.Options, emulator[0], args...)
-			daemon.Stdout = os.Stdout
-			daemon.Stderr = os.Stderr
-		case "simavr":
-			port = ":1234"
-			// Run in an emulator.
-			args := append(emulator[1:], "-g")
-			daemon = executeCommand(config.Options, emulator[0], args...)
-			daemon.Stdout = os.Stdout
-			daemon.Stderr = os.Stderr
-		case "msd":
-			return errors.New("gdb is not supported for drag-and-drop programmable devices")
-		default:
-			return fmt.Errorf("gdb is not supported with interface %#v", gdbInterface)
-		}
-
-		if daemon != nil {
-			// Make sure the daemon doesn't receive Ctrl-C that is intended for
-			// GDB (to break the currently executing program).
-			setCommandAsDaemon(daemon)
-
-			// Start now, and kill it on exit.
-			err = daemon.Start()
-			if err != nil {
-				return &commandError{"failed to run", daemon.Path, err}
-			}
-			defer func() {
-				daemon.Process.Signal(os.Interrupt)
-				var stopped uint32
-				go func() {
-					time.Sleep(time.Millisecond * 100)
-					if atomic.LoadUint32(&stopped) == 0 {
-						daemon.Process.Kill()
-					}
-				}()
-				daemon.Wait()
-				atomic.StoreUint32(&stopped, 1)
-			}()
-		}
-
-		// Ignore Ctrl-C, it must be passed on to GDB.
-		c := make(chan os.Signal, 1)
-		signal.Notify(c, os.Interrupt)
-		go func() {
-			for range c {
-			}
-		}()
-
-		// Construct and execute a gdb or lldb command.
-		// By default: gdb -ex run <binary>
-		// Exit the debugger with Ctrl-D.
-		params := []string{result.Executable}
-		switch debugger {
-		case "gdb":
-			if port != "" {
-				params = append(params, "-ex", "target extended-remote "+port)
-			}
-			for _, cmd := range gdbCommands {
-				params = append(params, "-ex", cmd)
-			}
-		case "lldb":
-			params = append(params, "--arch", config.Triple())
-			if port != "" {
-				if strings.HasPrefix(port, ":") {
-					params = append(params, "-o", "gdb-remote "+port[1:])
-				} else {
-					return fmt.Errorf("cannot use LLDB over a gdb-remote that isn't a TCP port: %s", port)
-				}
-			}
-			for _, cmd := range gdbCommands {
-				if strings.HasPrefix(cmd, "monitor ") {
-					params = append(params, "-o", "process plugin packet "+cmd)
-				} else if cmd == "load" {
-					params = append(params, "-o", "target modules load --load --slide 0")
-				} else {
-					return fmt.Errorf("don't know how to convert GDB command %#v to LLDB", cmd)
-				}
-			}
-		}
-		cmd := executeCommand(config.Options, cmdName, params...)
-		cmd.Stdin = os.Stdin
-		cmd.Stdout = os.Stdout
-		cmd.Stderr = os.Stderr
-		err = cmd.Run()
 		if err != nil {
-			return &commandError{"failed to run " + cmdName + " with", result.Executable, err}
+			return err
 		}
-		return nil
+		daemon = executeCommand(config.Options, "openocd", args...)
-	})
+		if ocdOutput {
+			// Make it clear which output is from the daemon.
+			w := &ColorWriter{
+				Out:    colorable.NewColorableStderr(),
+				Prefix: "openocd: ",
+				Color:  TermColorYellow,
+			}
+			daemon.Stdout = w
+			daemon.Stderr = w
+		}
+	case "jlink":
+		port = ":2331"
+		gdbCommands = append(gdbCommands, "load", "monitor reset halt")
+
+		// We need a separate debugging daemon for on-chip debugging.
+		daemon = executeCommand(config.Options, "JLinkGDBServer", "-device", config.Target.JLinkDevice)
+		if ocdOutput {
+			// Make it clear which output is from the daemon.
+			w := &ColorWriter{
+				Out:    colorable.NewColorableStderr(),
+				Prefix: "jlink: ",
+				Color:  TermColorYellow,
+			}
+			daemon.Stdout = w
+			daemon.Stderr = w
+		}
+	case "qemu":
+		port = ":1234"
+		// Run in an emulator.
+		args := append(emulator[1:], "-s", "-S")
+		daemon = executeCommand(config.Options, emulator[0], args...)
+		daemon.Stdout = os.Stdout
+		daemon.Stderr = os.Stderr
+	case "qemu-user":
+		port = ":1234"
+		// Run in an emulator.
+		args := append(emulator[1:], "-g", "1234")
+		daemon = executeCommand(config.Options, emulator[0], args...)
+		daemon.Stdout = os.Stdout
+		daemon.Stderr = os.Stderr
+	case "mgba":
+		port = ":2345"
+		// Run in an emulator.
+		args := append(emulator[1:], "-g")
+		daemon = executeCommand(config.Options, emulator[0], args...)
+		daemon.Stdout = os.Stdout
+		daemon.Stderr = os.Stderr
+	case "simavr":
+		port = ":1234"
+		// Run in an emulator.
+		args := append(emulator[1:], "-g")
+		daemon = executeCommand(config.Options, emulator[0], args...)
+		daemon.Stdout = os.Stdout
+		daemon.Stderr = os.Stderr
+	case "msd":
+		return errors.New("gdb is not supported for drag-and-drop programmable devices")
+	default:
+		return fmt.Errorf("gdb is not supported with interface %#v", gdbInterface)
+	}
+
+	if daemon != nil {
+		// Make sure the daemon doesn't receive Ctrl-C that is intended for
+		// GDB (to break the currently executing program).
+		setCommandAsDaemon(daemon)
+
+		// Start now, and kill it on exit.
+		err = daemon.Start()
+		if err != nil {
+			return &commandError{"failed to run", daemon.Path, err}
+		}
+		defer func() {
+			daemon.Process.Signal(os.Interrupt)
+			var stopped uint32
+			go func() {
+				time.Sleep(time.Millisecond * 100)
+				if atomic.LoadUint32(&stopped) == 0 {
+					daemon.Process.Kill()
+				}
+			}()
+			daemon.Wait()
+			atomic.StoreUint32(&stopped, 1)
+		}()
+	}
+
+	// Ignore Ctrl-C, it must be passed on to GDB.
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, os.Interrupt)
+	go func() {
+		for range c {
+		}
+	}()
+
+	// Construct and execute a gdb or lldb command.
+	// By default: gdb -ex run <binary>
+	// Exit the debugger with Ctrl-D.
+	params := []string{result.Executable}
+	switch debugger {
+	case "gdb":
+		if port != "" {
+			params = append(params, "-ex", "target extended-remote "+port)
+		}
+		for _, cmd := range gdbCommands {
+			params = append(params, "-ex", cmd)
+		}
+	case "lldb":
+		params = append(params, "--arch", config.Triple())
+		if port != "" {
+			if strings.HasPrefix(port, ":") {
+				params = append(params, "-o", "gdb-remote "+port[1:])
+			} else {
+				return fmt.Errorf("cannot use LLDB over a gdb-remote that isn't a TCP port: %s", port)
+			}
+		}
+		for _, cmd := range gdbCommands {
+			if strings.HasPrefix(cmd, "monitor ") {
+				params = append(params, "-o", "process plugin packet "+cmd)
+			} else if cmd == "load" {
+				params = append(params, "-o", "target modules load --load --slide 0")
+			} else {
+				return fmt.Errorf("don't know how to convert GDB command %#v to LLDB", cmd)
+			}
+		}
+	}
+	cmd := executeCommand(config.Options, cmdName, params...)
+	cmd.Stdin = os.Stdin
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	err = cmd.Run()
+	if err != nil {
+		return &commandError{"failed to run " + cmdName + " with", result.Executable, err}
+	}
+	return nil
 }
 
 // Run compiles and runs the given program. Depending on the target provided in
@@ -707,16 +752,17 @@ func Run(pkgName string, options *compileopts.Options, cmdArgs []string) error {
 		return err
 	}
 
-	return buildAndRun(pkgName, config, os.Stdout, cmdArgs, nil, 0, func(cmd *exec.Cmd, result builder.BuildResult) error {
+	_, err = buildAndRun(pkgName, config, os.Stdout, cmdArgs, nil, 0, func(cmd *exec.Cmd, result builder.BuildResult) error {
 		return cmd.Run()
 	})
+	return err
 }
 
 // buildAndRun builds and runs the given program, writing output to stdout and
 // errors to os.Stderr. It takes care of emulators (qemu, wasmtime, etc) and
 // passes command line arguments and evironment variables in a way appropriate
 // for the given emulator.
-func buildAndRun(pkgName string, config *compileopts.Config, stdout io.Writer, cmdArgs, environmentVars []string, timeout time.Duration, run func(cmd *exec.Cmd, result builder.BuildResult) error) error {
+func buildAndRun(pkgName string, config *compileopts.Config, stdout io.Writer, cmdArgs, environmentVars []string, timeout time.Duration, run func(cmd *exec.Cmd, result builder.BuildResult) error) (builder.BuildResult, error) {
 	// Determine whether we're on a system that supports environment variables
 	// and command line parameters (operating systems, WASI) or not (baremetal,
 	// WebAssembly in the browser). If we're on a system without an environment,
@@ -767,69 +813,82 @@ func buildAndRun(pkgName string, config *compileopts.Config, stdout io.Writer, c
 		env = environmentVars
 	}
 
+	// Create a temporary directory for intermediary files.
+	tmpdir, err := os.MkdirTemp("", "tinygo")
+	if err != nil {
+		return builder.BuildResult{}, err
+	}
+	if !config.Options.Work {
+		defer os.RemoveAll(tmpdir)
+	}
+
+	// Build the binary to be run.
 	format, fileExt := config.EmulatorFormat()
-	return builder.Build(pkgName, fileExt, config, func(result builder.BuildResult) error {
+	result, err := builder.Build(pkgName, fileExt, tmpdir, config)
-		// If needed, set a timeout on the command. This is done in tests so
+	if err != nil {
-		// they don't waste resources on a stalled test.
+		return result, err
-		var ctx context.Context
+	}
-		if timeout != 0 {
-			var cancel context.CancelFunc
-			ctx, cancel = context.WithTimeout(context.Background(), timeout)
-			defer cancel()
-		}
 
-		// Set up the command.
+	// If needed, set a timeout on the command. This is done in tests so
-		var name string
+	// they don't waste resources on a stalled test.
-		if config.Target.Emulator == "" {
+	var ctx context.Context
-			name = result.Binary
+	if timeout != 0 {
-		} else {
+		var cancel context.CancelFunc
-			emulator, err := config.Emulator(format, result.Binary)
+		ctx, cancel = context.WithTimeout(context.Background(), timeout)
-			if err != nil {
+		defer cancel()
-				return err
+	}
-			}
-			name = emulator[0]
-			emuArgs := append([]string(nil), emulator[1:]...)
-			args = append(emuArgs, args...)
-		}
-		var cmd *exec.Cmd
-		if ctx != nil {
-			cmd = exec.CommandContext(ctx, name, args...)
-		} else {
-			cmd = exec.Command(name, args...)
-		}
-		cmd.Env = env
 
-		// Configure stdout/stderr. The stdout may go to a buffer, not a real
+	// Set up the command.
-		// stdout.
+	var name string
-		cmd.Stdout = stdout
+	if config.Target.Emulator == "" {
-		cmd.Stderr = os.Stderr
+		name = result.Binary
-		if config.EmulatorName() == "simavr" {
+	} else {
-			cmd.Stdout = nil // don't print initial load commands
+		emulator, err := config.Emulator(format, result.Binary)
-			cmd.Stderr = stdout
-		}
-
-		// If this is a test, reserve CPU time for it so that increased
-		// parallelism doesn't blow up memory usage. If this isn't a test but
-		// simply `tinygo run`, then it is practically a no-op.
-		config.Options.Semaphore <- struct{}{}
-		defer func() {
-			<-config.Options.Semaphore
-		}()
-
-		// Run binary.
-		if config.Options.PrintCommands != nil {
-			config.Options.PrintCommands(cmd.Path, cmd.Args...)
-		}
-		err := run(cmd, result)
 		if err != nil {
-			if ctx != nil && ctx.Err() == context.DeadlineExceeded {
+			return result, err
-				stdout.Write([]byte(fmt.Sprintf("--- timeout of %s exceeded, terminating...\n", timeout)))
-				err = ctx.Err()
-			}
-			return &commandError{"failed to run compiled binary", result.Binary, err}
 		}
-		return nil
+		name = emulator[0]
-	})
+		emuArgs := append([]string(nil), emulator[1:]...)
+		args = append(emuArgs, args...)
+	}
+	var cmd *exec.Cmd
+	if ctx != nil {
+		cmd = exec.CommandContext(ctx, name, args...)
+	} else {
+		cmd = exec.Command(name, args...)
+	}
+	cmd.Env = env
+
+	// Configure stdout/stderr. The stdout may go to a buffer, not a real
+	// stdout.
+	cmd.Stdout = stdout
+	cmd.Stderr = os.Stderr
+	if config.EmulatorName() == "simavr" {
+		cmd.Stdout = nil // don't print initial load commands
+		cmd.Stderr = stdout
+	}
+
+	// If this is a test, reserve CPU time for it so that increased
+	// parallelism doesn't blow up memory usage. If this isn't a test but
+	// simply `tinygo run`, then it is practically a no-op.
+	config.Options.Semaphore <- struct{}{}
+	defer func() {
+		<-config.Options.Semaphore
+	}()
+
+	// Run binary.
+	if config.Options.PrintCommands != nil {
+		config.Options.PrintCommands(cmd.Path, cmd.Args...)
+	}
+	err = run(cmd, result)
+	if err != nil {
+		if ctx != nil && ctx.Err() == context.DeadlineExceeded {
+			stdout.Write([]byte(fmt.Sprintf("--- timeout of %s exceeded, terminating...\n", timeout)))
+			err = ctx.Err()
+		}
+		return result, &commandError{"failed to run compiled binary", result.Binary, err}
+	}
+	return result, nil
 }
 
 func touchSerialPortAt1200bps(port string) (err error) {
@@ -857,8 +916,6 @@ func touchSerialPortAt1200bps(port string) (err error) {
 	return fmt.Errorf("opening port: %s", err)
 }
 
-const maxMSDRetries = 10
-
 func flashUF2UsingMSD(volume, tmppath string, options *compileopts.Options) error {
 	// find standard UF2 info path
 	var infoPath string
@@ -880,7 +937,7 @@ func flashUF2UsingMSD(volume, tmppath string, options *compileopts.Options) erro
 		infoPath = path + "/INFO_UF2.TXT"
 	}
 
-	d, err := locateDevice(volume, infoPath)
+	d, err := locateDevice(volume, infoPath, options.Timeout)
 	if err != nil {
 		return err
 	}
@@ -909,7 +966,7 @@ func flashHexUsingMSD(volume, tmppath string, options *compileopts.Options) erro
 		destPath = path + "/"
 	}
 
-	d, err := locateDevice(volume, destPath)
+	d, err := locateDevice(volume, destPath, options.Timeout)
 	if err != nil {
 		return err
 	}
@@ -917,10 +974,10 @@ func flashHexUsingMSD(volume, tmppath string, options *compileopts.Options) erro
 	return moveFile(tmppath, d+"/flash.hex")
 }
 
-func locateDevice(volume, path string) (string, error) {
+func locateDevice(volume, path string, timeout time.Duration) (string, error) {
 	var d []string
 	var err error
-	for i := 0; i < maxMSDRetries; i++ {
+	for start := time.Now(); time.Since(start) < timeout; {
 		d, err = filepath.Glob(path)
 		if err != nil {
 			return "", err
@@ -980,18 +1037,14 @@ func getDefaultPort(portFlag string, usbInterfaces []string) (port string, err e
 		var preferredPortIDs [][2]uint16
 		for _, s := range usbInterfaces {
 			parts := strings.Split(s, ":")
-			if len(parts) != 3 || (parts[0] != "acm" && parts[0] == "usb") {
+			if len(parts) != 2 {
-				// acm and usb are the two types of serial ports recognized
+				return "", fmt.Errorf("could not parse USB VID/PID pair %q", s)
-				// under Linux (ttyACM*, ttyUSB*). Other operating systems don't
-				// generally make this distinction. If this is not one of the
-				// given USB devices, don't try to parse the USB IDs.
-				continue
 			}
-			vid, err := strconv.ParseUint(parts[1], 16, 16)
+			vid, err := strconv.ParseUint(parts[0], 16, 16)
 			if err != nil {
 				return "", fmt.Errorf("could not parse USB vendor ID %q: %w", parts[1], err)
 			}
-			pid, err := strconv.ParseUint(parts[2], 16, 16)
+			pid, err := strconv.ParseUint(parts[1], 16, 16)
 			if err != nil {
 				return "", fmt.Errorf("could not parse USB product ID %q: %w", parts[1], err)
 			}
@@ -1331,9 +1384,9 @@ func main() {
 	ocdCommandsString := flag.String("ocd-commands", "", "OpenOCD commands, overriding target spec (can specify multiple separated by commas)")
 	ocdOutput := flag.Bool("ocd-output", false, "print OCD daemon output during debug")
 	port := flag.String("port", "", "flash port (can specify multiple candidates separated by commas)")
+	timeout := flag.Duration("timeout", 20*time.Second, "the length of time to retry locating the MSD volume to be used for flashing")
 	programmer := flag.String("programmer", "", "which hardware programmer to use")
 	ldflags := flag.String("ldflags", "", "Go link tool compatible ldflags")
-	wasmAbi := flag.String("wasm-abi", "", "WebAssembly ABI conventions: js (no i64 params) or generic")
 	llvmFeatures := flag.String("llvm-features", "", "comma separated LLVM features to enable")
 	cpuprofile := flag.String("cpuprofile", "", "cpuprofile output")
 	monitor := flag.Bool("monitor", false, "enable serial monitor")
@@ -1422,13 +1475,13 @@ func main() {
 		PrintAllocs:     printAllocs,
 		Tags:            []string(tags),
 		GlobalValues:    globalVarValues,
-		WasmAbi:         *wasmAbi,
 		Programmer:      *programmer,
 		OpenOCDCommands: ocdCommands,
 		LLVMFeatures:    *llvmFeatures,
 		PrintJSON:       flagJSON,
 		Monitor:         *monitor,
 		BaudRate:        *baudrate,
+		Timeout:         *timeout,
 	}
 	if *printCommands {
 		options.PrintCommands = printCommand
@@ -1616,7 +1669,6 @@ func main() {
 		wg.Wait()
 		close(fail)
 		if _, fail := <-fail; fail {
-			fmt.Println("FAIL")
 			os.Exit(1)
 		}
 	case "monitor":

main_test.go

@@ -134,10 +134,7 @@ func TestBuild(t *testing.T) {
 	})
 
 	t.Run("AVR", func(t *testing.T) {
-		// LLVM backend crash:
+		t.Parallel()
-		// LIBCLANG FATAL ERROR: Cannot select: t3: i16 = JumpTable<0>
-		// This bug is non-deterministic.
-		t.Skip("skipped due to non-deterministic backend bugs")
 		runPlatTests(optionsFromTarget("simavr", sema), tests, t)
 	})
 
@@ -194,10 +191,6 @@ func runPlatTests(options compileopts.Options, tests []string, t *testing.T) {
 				// Breaks interp.
 				continue
 
-			case "channel.go":
-				// Freezes after recv from closed channel.
-				continue
-
 			case "math.go":
 				// Stuck somewhere, not sure what's happening.
 				continue
@@ -336,7 +329,7 @@ func runTestWithConfig(name string, t *testing.T, options compileopts.Options, c
 
 	// Build the test binary.
 	stdout := &bytes.Buffer{}
-	err = buildAndRun("./"+path, config, stdout, cmdArgs, environmentVars, time.Minute, func(cmd *exec.Cmd, result builder.BuildResult) error {
+	_, err = buildAndRun("./"+path, config, stdout, cmdArgs, environmentVars, time.Minute, func(cmd *exec.Cmd, result builder.BuildResult) error {
 		return cmd.Run()
 	})
 	if err != nil {

src/crypto/rand/rand_arc4random.go

@@ -1,5 +1,4 @@
 //go:build darwin || tinygo.wasm
-// +build darwin tinygo.wasm
 
 // This implementation of crypto/rand uses the arc4random_buf function
 // (available on both MacOS and WASI) to generate random numbers.

src/crypto/rand/rand_baremetal.go

@@ -1,5 +1,4 @@
 //go:build nrf || stm32 || (sam && atsamd51) || (sam && atsame5x)
-// +build nrf stm32 sam,atsamd51 sam,atsame5x
 
 package rand
 

src/crypto/rand/rand_urandom.go

@@ -1,5 +1,4 @@
 //go:build linux && !baremetal && !wasi
-// +build linux,!baremetal,!wasi
 
 // This implementation of crypto/rand uses the /dev/urandom pseudo-file to
 // generate random numbers.

src/device/arm/scb.go

@@ -2,7 +2,6 @@
 // Cortex-M System Control Block-related definitions.
 
 //go:build cortexm
-// +build cortexm
 
 package arm
 

src/device/avr/avr_tiny85.go

@@ -1,5 +1,4 @@
 //go:build avr && attiny85
-// +build avr,attiny85
 
 package avr
 

src/device/nxp/hardfault.go

@@ -3,7 +3,6 @@
 // auto-generated by gen-device-svd.go) among devices in package nxp.
 
 //go:build nxp && !mimxrt1062
-// +build nxp,!mimxrt1062
 
 package nxp
 

src/device/nxp/mimxrt1062_clock.go

@@ -3,7 +3,6 @@
 // peripherals of the NXP MIMXRT1062.
 
 //go:build nxp && mimxrt1062
-// +build nxp,mimxrt1062
 
 package nxp
 

src/device/nxp/mimxrt1062_hardfault.go

@@ -3,7 +3,6 @@
 // auto-generated by gen-device-svd.go) among devices in package nxp.
 
 //go:build nxp && mimxrt1062
-// +build nxp,mimxrt1062
 
 package nxp
 

src/device/nxp/mimxrt1062_mpu.go

@@ -3,7 +3,6 @@
 // of the NXP MIMXRT1062.
 
 //go:build nxp && mimxrt1062
-// +build nxp,mimxrt1062
 
 package nxp
 

src/device/sam/atsamd51x-bitfields.go

@@ -2,7 +2,6 @@
 // atsamd51x bitfield definitions that are not auto-generated by gen-device-svd.go
 
 //go:build sam && atsamd51
-// +build sam,atsamd51
 
 // These are the supported pchctrl function numberings on the atsamd51x
 // See http://ww1.microchip.com/downloads/en/DeviceDoc/SAM_D5xE5x_Family_Data_Sheet_DS60001507F.pdf