runtime: use exitGoroutine instead of deadlock

This makes the meaning more clear. And while the behavior is currently
the same, when we start to use threads we should actually exit the
goroutine when calling runtime.Goexit() instead of just leaving it
deadlocked.

.circleci/config.yml

@@ -73,14 +73,6 @@ commands:
             - go-cache-v4-{{ checksum "go.mod" }}
       - llvm-source-linux
       - run: go install -tags=llvm<<parameters.llvm>> .
-      - restore_cache:
-          keys:
-            - wasi-libc-sysroot-systemclang-v7
-      - run: make wasi-libc
-      - save_cache:
-          key: wasi-libc-sysroot-systemclang-v7
-          paths:
-            - lib/wasi-libc/sysroot
       - when:
           condition: <<parameters.fmt-check>>
           steps:
@@ -109,9 +101,9 @@ jobs:
           # "make lint" fails before go 1.21 because internal/tools/go.mod specifies packages that require go 1.21
           fmt-check: false
     resource_class: large
-  test-llvm19-go123:
+  test-llvm19-go124:
     docker:
-      - image: golang:1.23-bullseye
+      - image: golang:1.24-bullseye
     steps:
       - test-linux:
           llvm: "19"
@@ -124,4 +116,4 @@ workflows:
       # least the smoke tests still pass.
       - test-llvm15-go119
       # This tests LLVM 19 support when linking against system libraries.
-      - test-llvm19-go123
+      - test-llvm19-go124

.github/workflows/build-macos.yml

@@ -39,7 +39,7 @@ jobs:
       - name: Install Go
         uses: actions/setup-go@v5
         with:
-          go-version: '1.23'
+          go-version: '1.24'
           cache: true
       - name: Restore LLVM source cache
         uses: actions/cache/restore@v4
@@ -89,15 +89,6 @@ jobs:
         with:
           key: ${{ steps.cache-llvm-build.outputs.cache-primary-key }}
           path: llvm-build
-      - name: Cache wasi-libc sysroot
-        uses: actions/cache@v4
-        id: cache-wasi-libc
-        with:
-          key: wasi-libc-sysroot-${{ matrix.os }}-v1
-          path: lib/wasi-libc/sysroot
-      - name: Build wasi-libc
-        if: steps.cache-wasi-libc.outputs.cache-hit != 'true'
-        run: make wasi-libc
       - name: make gen-device
         run: make -j3 gen-device
       - name: Test TinyGo
@@ -143,7 +134,7 @@ jobs:
       - name: Install Go
         uses: actions/setup-go@v5
         with:
-          go-version: '1.23'
+          go-version: '1.24'
           cache: true
       - name: Build TinyGo (LLVM ${{ matrix.version }})
         run: go install -tags=llvm${{ matrix.version }}

.github/workflows/linux.yml

@@ -18,7 +18,7 @@ jobs:
     # statically linked binary.
     runs-on: ubuntu-latest
     container:
-      image: golang:1.23-alpine
+      image: golang:1.24-alpine
     outputs:
       version: ${{ steps.version.outputs.version }}
     steps:
@@ -104,15 +104,6 @@ jobs:
         run: |
           apk add cmake samurai python3
           make binaryen STATIC=1
-      - name: Cache wasi-libc
-        uses: actions/cache@v4
-        id: cache-wasi-libc
-        with:
-          key: wasi-libc-sysroot-linux-alpine-v2
-          path: lib/wasi-libc/sysroot
-      - name: Build wasi-libc
-        if: steps.cache-wasi-libc.outputs.cache-hit != 'true'
-        run: make wasi-libc
       - name: Install fpm
         run: |
           gem install --version 4.0.7 public_suffix
@@ -146,7 +137,7 @@ jobs:
       - name: Install Go
         uses: actions/setup-go@v5
         with:
-          go-version: '1.23'
+          go-version: '1.24'
           cache: true
       - name: Install wasmtime
         uses: bytecodealliance/actions/wasmtime/setup@v1
@@ -165,6 +156,7 @@ jobs:
           ln -s ~/lib/tinygo/bin/tinygo ~/go/bin/tinygo
       - run: make tinygo-test-wasip1-fast
       - run: make tinygo-test-wasip2-fast
+      - run: make tinygo-test-wasm
       - run: make smoketest
   assert-test-linux:
     # Run all tests that can run on Linux, with LLVM assertions enabled to catch
@@ -189,7 +181,7 @@ jobs:
       - name: Install Go
         uses: actions/setup-go@v5
         with:
-          go-version: '1.23'
+          go-version: '1.24'
           cache: true
       - name: Install Node.js
         uses: actions/setup-node@v4
@@ -257,15 +249,6 @@ jobs:
       - name: Build Binaryen
         if: steps.cache-binaryen.outputs.cache-hit != 'true'
         run: make binaryen
-      - name: Cache wasi-libc
-        uses: actions/cache@v4
-        id: cache-wasi-libc
-        with:
-          key: wasi-libc-sysroot-linux-asserts-v6
-          path: lib/wasi-libc/sysroot
-      - name: Build wasi-libc
-        if: steps.cache-wasi-libc.outputs.cache-hit != 'true'
-        run: make wasi-libc
       - run: make gen-device -j4
       - name: Test TinyGo
         run: make ASSERT=1 test
@@ -277,7 +260,7 @@ jobs:
         run: make tinygo-test
       - run: make smoketest
       - run: make wasmtest
-      - run: make tinygo-baremetal
+      - run: make tinygo-test-baremetal
   build-linux-cross:
     # Build ARM Linux binaries, ready for release.
     # This intentionally uses an older Linux image, so that we compile against
@@ -297,7 +280,7 @@ jobs:
           - goarch: arm
             toolchain: arm-linux-gnueabihf
             libc: armhf
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04 # note: use the oldest image available! (see above)
     needs: build-linux
     steps:
       - name: Checkout
@@ -315,7 +298,7 @@ jobs:
       - name: Install Go
         uses: actions/setup-go@v5
         with:
-          go-version: '1.23'
+          go-version: '1.24'
           cache: true
       - name: Restore LLVM source cache
         uses: actions/cache/restore@v4
@@ -346,7 +329,7 @@ jobs:
         uses: actions/cache/restore@v4
         id: cache-llvm-build
         with:
-          key: llvm-build-19-linux-${{ matrix.goarch }}-v2
+          key: llvm-build-19-linux-${{ matrix.goarch }}-v3
           path: llvm-build
       - name: Build LLVM
         if: steps.cache-llvm-build.outputs.cache-hit != 'true'

.github/workflows/nix.yml

@@ -22,9 +22,9 @@ jobs:
         run: sudo apt-get remove llvm-18
       - name: Checkout
         uses: actions/checkout@v4
-      - name: Pull musl
+      - name: Pull musl, bdwgc
         run: |
-            git submodule update --init lib/musl
+            git submodule update --init lib/musl lib/bdwgc
       - name: Restore LLVM source cache
         uses: actions/cache/restore@v4
         id: cache-llvm-source

.github/workflows/windows.yml

@@ -41,7 +41,7 @@ jobs:
       - name: Install Go
         uses: actions/setup-go@v5
         with:
-          go-version: '1.23'
+          go-version: '1.24'
           cache: true
       - name: Restore cached LLVM source
         uses: actions/cache/restore@v4
@@ -91,15 +91,6 @@ jobs:
         with:
           key: ${{ steps.cache-llvm-build.outputs.cache-primary-key }}
           path: llvm-build
-      - name: Cache wasi-libc sysroot
-        uses: actions/cache@v4
-        id: cache-wasi-libc
-        with:
-          key: wasi-libc-sysroot-v5
-          path: lib/wasi-libc/sysroot
-      - name: Build wasi-libc
-        if: steps.cache-wasi-libc.outputs.cache-hit != 'true'
-        run: make wasi-libc
       - name: Cache Go cache
         uses: actions/cache@v4
         with:
@@ -156,7 +147,7 @@ jobs:
       - name: Install Go
         uses: actions/setup-go@v5
         with:
-          go-version: '1.23'
+          go-version: '1.24'
           cache: true
       - name: Download TinyGo build
         uses: actions/download-artifact@v4
@@ -186,7 +177,7 @@ jobs:
       - name: Install Go
         uses: actions/setup-go@v5
         with:
-          go-version: '1.23'
+          go-version: '1.24'
           cache: true
       - name: Download TinyGo build
         uses: actions/download-artifact@v4
@@ -222,7 +213,7 @@ jobs:
       - name: Install Go
         uses: actions/setup-go@v5
         with:
-          go-version: '1.23'
+          go-version: '1.24'
           cache: true
       - name: Download TinyGo build
         uses: actions/download-artifact@v4

.gitmodules

@@ -39,3 +39,6 @@
 [submodule "lib/wasi-cli"]
 	path = lib/wasi-cli
 	url = https://github.com/WebAssembly/wasi-cli
+[submodule "lib/bdwgc"]
+	path = lib/bdwgc
+	url = https://github.com/ivmai/bdwgc.git

CHANGELOG.md

@@ -1,3 +1,122 @@
+0.37.0
+---
+* **general**
+  - add the Boehm-Demers-Weiser GC on Linux
+* **ci**
+  - add more tests for wasm and baremetal
+* **compiler**
+  - crypto/internal/sysrand is allowed to use unsafe signatures
+* **examples**
+  - add goroutine benchmark to examples
+* **fixes**
+  - ensure use of pointers for SPI interface on atsam21/atsam51 and other machines/boards that were missing implementation (#4798)
+  - replace loop counter with hw timer for USB SetAddressReq on rp2040 (#4796)
+* **internal**
+  - update to go.bytecodealliance.org@v0.6.2 in GNUmakefile and internal/wasm-tools
+  - exclude certain files when copying package in internal/cm
+  - update to go.bytecodealliance.org/cm@v0.2.2 in internal/cm
+  - remove old reflect.go in internal/reflectlite
+* **loader**
+  - use build tags for package iter and iter methods on reflect.Value in loader, iter, reflect
+  - add shim for go1.22 and earlier in loader, iter
+* **machine**
+  - bump rp2040 to 200MHz (#4768)
+  - correct register address for Pin.SetInterrupt for rp2350 (#4782)
+  - don't block the rp2xxx UART interrupt handler
+  - fix RP2040 Pico board on the playground
+  - add flash support for rp2350 (#4803)
+* **os**
+  - add stub Symlink for wasm
+* **refactor**
+  - use *SPI everywhere to make consistent for implementations. Fixes #4663 "in reverse" by making SPI a pointer everywhere, as discussed in the comments.
+* **reflect**
+  - add Value.SetIter{Key,Value} and MapIter.Reset in reflect, internal/reflectlite
+  - embed reflectlite types into reflect types in reflect, internal/reflectlite
+  - add Go 1.24 iter.Seq[2] methods
+  - copy reflect iter tests from upstream Go
+  - panic on Type.CanSeq[2] instead of returning false
+  - remove strconv.go
+  - remove unused go:linkname functions
+* **riscv-qemu**
+  - add VirtIO RNG device
+  - increase stack size
+* **runtime**
+  - only allocate heap memory when needed
+  - remove unused file func.go
+  - use package reflectlite
+* **transform**
+  - cherry-pick from #4774
+
+
+0.36.0
+---
+* **general**
+  - add initial Go 1.24 support
+  - add support for LLVM 19
+  - update license for 2025
+  - make small corrections for README regarding wasm
+  - use GOOS and GOARCH for building wasm simulated boards
+  - only infer target for wasm when GOOS and GOARCH are set correctly, not just based on file extension
+  - add test-corpus-wasip2
+  - use older image for cross-compiling builds
+  - update Linux builds to run on ubuntu-latest since 20.04 is being retired
+  - ensure build output directory is created
+  - add NoSandbox flag to chrome headless that is run during WASM tests, since this is now required for Ubuntu 23+ and we are using Ubuntu 24+ when running Github Actions
+  - update wasmtime used for CI to 29.0.1 to fix issue with install during CI tests
+  - update to use `Get-CimInstance` as `wmic` is being deprecated on WIndows
+  - remove unnecessary executable permissions
+  - `goenv`: update to new v0.36.0 development version
+* **compiler**
+  - `builder`: fix parsing of external ld.lld error messages
+  - `cgo`: mangle identifier names
+  - `interp`: correctly mark functions as modifying memory
+  - add buildmode=wasi-legacy to support existing base of users who expected the older behavior for wasi modules to not return an exit code as if they were reactors
+* **standard library**
+  - `crypto/tls`: add Dialer.DialContext() to fix websocket client
+  - `crypto/tls`: add VersionTLS constants and VersionName(version uint16) method that turns it into a string, copied from big go
+  - `internal/syscall/unix`: use our own version of this package
+  - `machine`: replace hard-coded cpu frequencies on rp2xxx
+  - `machine`: bump rp2350 CPUFrequency to 150 MHz
+  - `machine`: compute rp2 clock dividers from crystal and target frequency
+  - `machine`: remove bytes package dependency in flash code
+  - `machine/usb/descriptor`: avoid bytes package
+  - `net`: update to latest submodule with httptest subpackage and ResolveIPAddress implementation
+  - `os`: add File.Chdir support
+  - `os`: implement stub Chdir for non-OS systems
+  - `os/file`: add file.Chmod
+  - `reflect`: implement Value.Equal
+  - `runtime`: add FIPS helper functions
+  - `runtime`: manually initialize xorshift state
+  - `sync`: move Mutex to internal/task
+  - `syscall`: add wasip1 RandomGet
+  - `testing`: add Chdir
+  - `wasip2`: add stubs to get internal/syscall/unix to work
+* **fixes**
+  - correctly handle calls for GetRNG() when being made from nrf devices with SoftDevice enabled
+  - fix stm32f103 ADC
+  - `wasm`: correctly handle id lookup for finalizeRef call
+  - `wasm`: avoid total failure on wasm finalizer call
+  - `wasm`: convert offset as signed int into unsigned int in syscall/js.stringVal in wasm_exec.js
+* **targets**
+  - rp2350: add pll generalized solution; fix ADC handles; pwm period fix
+  - rp2350: extending support to include the rp2350b
+  - rp2350: cleanup: unexport internal USB and clock package variable, consts and types
+  - nrf: make ADC resolution changeable
+  - turn on GC for TKey1 device, since it does in fact work
+  - match Pico2 stack size to Pico
+* **boards**
+  - add support for Pimoroni Pico Plus2
+  - add target for pico2-w board
+  - add comboat_fw tag for elecrow W5 boards with Combo-AT Wifi firmware
+  - add support for Elecrow Pico rp2350 W5 boards
+  - add support for Elecrow Pico rp2040 W5 boards
+  - add support for NRF51 HW-651
+  - add support for esp32c3-supermini
+  - add support for waveshare-rp2040-tiny
+* **examples**
+  - add naive debouncing for pininterrupt example
+
+
 0.35.0
 ---
 * **general**

Dockerfile

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

GNUmakefile

@@ -8,13 +8,20 @@ LLVM_PROJECTDIR ?= llvm-project
 CLANG_SRC ?= $(LLVM_PROJECTDIR)/clang
 LLD_SRC ?= $(LLVM_PROJECTDIR)/lld
 
+ifeq ($(OS),Windows_NT)
+    # avoid calling uname on Windows
+    uname := Windows_NT
+else
+    uname := $(shell uname -s)
+endif
+
 # Try to autodetect LLVM build tools.
 # Versions are listed here in descending priority order.
 LLVM_VERSIONS = 19 18 17 16 15
 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)
-ifeq ($(shell uname -s),Darwin)
+ifeq ($(uname),Darwin)
 	# Also explicitly search Brew's copy, which is not in PATH by default.
 	BREW_PREFIX := $(shell brew --prefix)
 	toolSearchPathsVersion += $(BREW_PREFIX)/opt/llvm@$(2)/bin/$(1)-$(2) $(BREW_PREFIX)/opt/llvm@$(2)/bin/$(1)
@@ -27,7 +34,6 @@ LLVM_NM ?= $(call findLLVMTool,llvm-nm)
 
 # Go binary and GOROOT to select
 GO ?= go
-export GOROOT = $(shell $(GO) env GOROOT)
 
 # Flags to pass to go test.
 GOTESTFLAGS ?=
@@ -38,14 +44,10 @@ TINYGO ?= $(call detect,tinygo,tinygo $(CURDIR)/build/tinygo)
 
 # Check for ccache if the user hasn't set it to on or off.
 ifeq (, $(CCACHE))
-    # Use CCACHE for LLVM if possible
-    ifneq (, $(shell command -v ccache 2> /dev/null))
-        CCACHE := ON
-    else
-        CCACHE := OFF
-    endif
+    LLVM_OPTION += '-DLLVM_CCACHE_BUILD=$(if $(shell command -v ccache 2> /dev/null),ON,OFF)'
+else
+    LLVM_OPTION += '-DLLVM_CCACHE_BUILD=$(CCACHE)'
 endif
-LLVM_OPTION += '-DLLVM_CCACHE_BUILD=$(CCACHE)'
 
 # Allow enabling LLVM assertions
 ifeq (1, $(ASSERT))
@@ -127,14 +129,14 @@ ifeq ($(OS),Windows_NT)
 
     USE_SYSTEM_BINARYEN ?= 1
 
-else ifeq ($(shell uname -s),Darwin)
+else ifeq ($(uname),Darwin)
     MD5SUM ?= md5
 
     CGO_LDFLAGS += -lxar
 
     USE_SYSTEM_BINARYEN ?= 1
 
-else ifeq ($(shell uname -s),FreeBSD)
+else ifeq ($(uname),FreeBSD)
     MD5SUM ?= md5
     START_GROUP = -Wl,--start-group
     END_GROUP = -Wl,--end-group
@@ -259,40 +261,34 @@ build/wasm-opt$(EXE):
 	cp lib/binaryen/bin/wasm-opt$(EXE) build/wasm-opt$(EXE)
 endif
 
-# Build wasi-libc sysroot
-.PHONY: wasi-libc
-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 EXTRA_CFLAGS="-O2 -g -DNDEBUG -mnontrapping-fptoint -msign-ext" MALLOC_IMPL=none CC="$(CLANG)" AR=$(LLVM_AR) NM=$(LLVM_NM)
-
 # Generate WASI syscall bindings
-WASM_TOOLS_MODULE=github.com/bytecodealliance/wasm-tools-go
+WASM_TOOLS_MODULE=go.bytecodealliance.org
 .PHONY: wasi-syscall
 wasi-syscall: wasi-cm
+	rm -rf ./src/internal/wasi/*
 	go run -modfile ./internal/wasm-tools/go.mod $(WASM_TOOLS_MODULE)/cmd/wit-bindgen-go generate --versioned -o ./src/internal -p internal --cm internal/cm ./lib/wasi-cli/wit
 
 # Copy package cm into src/internal/cm
 .PHONY: wasi-cm
 wasi-cm:
-	# rm -rf ./src/internal/cm
-	rsync -rv --delete --exclude '*_test.go' $(shell go list -modfile ./internal/wasm-tools/go.mod -m -f {{.Dir}} $(WASM_TOOLS_MODULE))/cm ./src/internal/
+	rm -rf ./src/internal/cm/*
+	rsync -rv --delete --exclude go.mod --exclude '*_test.go' --exclude '*_json.go' --exclude '*.md' --exclude LICENSE $(shell go list -modfile ./internal/wasm-tools/go.mod -m -f {{.Dir}} $(WASM_TOOLS_MODULE)/cm)/ ./src/internal/cm
 
 # Check for Node.js used during WASM tests.
-NODEJS_VERSION := $(word 1,$(subst ., ,$(shell node -v | cut -c 2-)))
 MIN_NODEJS_VERSION=18
 
 .PHONY: check-nodejs-version
 check-nodejs-version:
-ifeq (, $(shell which node))
-	@echo "Install NodeJS version 18+ to run tests."; exit 1;
-endif
-	@if [ $(NODEJS_VERSION) -lt $(MIN_NODEJS_VERSION) ]; then echo "Install NodeJS version 18+ to run tests."; exit 1; fi
+	@# Check whether NodeJS is available.
+	@if ! command -v node 2>&1 >/dev/null; then echo "Install NodeJS version ${MIN_NODEJS_VERSION}+ to run tests."; exit 1; fi
+
+	@# Check whether the version is high enough.
+	@if [ "`node -v | sed 's/v\([0-9]\+\).*/\\1/g'`" -lt $(MIN_NODEJS_VERSION) ]; then echo "Install NodeJS version $(MIN_NODEJS_VERSION)+ to run tests."; exit 1; fi
 
 tinygo: ## Build the TinyGo compiler
 	@if [ ! -f "$(LLVM_BUILDDIR)/bin/llvm-config" ]; then echo "Fetch and build LLVM first by running:"; echo "  $(MAKE) llvm-source"; echo "  $(MAKE) $(LLVM_BUILDDIR)"; exit 1; fi
 	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GOENVFLAGS) $(GO) build -buildmode exe -o build/tinygo$(EXE) -tags "byollvm osusergo" .
-test: wasi-libc check-nodejs-version
+test: check-nodejs-version
 	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) test $(GOTESTFLAGS) -timeout=1h -buildmode exe -tags "byollvm osusergo" $(GOTESTPKGS)
 
 # Standard library packages that pass tests on darwin, linux, wasi, and windows, but take over a minute in wasi
@@ -309,11 +305,9 @@ TEST_PACKAGES_FAST = \
 	container/heap \
 	container/list \
 	container/ring \
-	crypto/des \
 	crypto/ecdsa \
 	crypto/elliptic \
 	crypto/md5 \
-	crypto/rc4 \
 	crypto/sha1 \
 	crypto/sha256 \
 	crypto/sha512 \
@@ -355,17 +349,11 @@ TEST_PACKAGES_FAST = \
 	unique \
 	$(nil)
 
-# Assume this will go away before Go2, so only check minor version.
-ifeq ($(filter $(shell $(GO) env GOVERSION | cut -f 2 -d.), 16 17 18), )
-TEST_PACKAGES_FAST += crypto/internal/nistec/fiat
-else
-TEST_PACKAGES_FAST += crypto/elliptic/internal/fiat
-endif
-
 # archive/zip requires os.ReadAt, which is not yet supported on windows
 # bytes requires mmap
 # compress/flate appears to hang on wasi
 # crypto/aes fails on wasi, needs panic()/recover()
+# crypto/des fails on wasi, needs panic()/recover()
 # crypto/hmac fails on wasi, it exits with a "slice out of range" panic
 # debug/plan9obj requires os.ReadAt, which is not yet supported on windows
 # image requires recover(), which is not yet supported on wasi
@@ -386,6 +374,7 @@ TEST_PACKAGES_LINUX := \
 	archive/zip \
 	compress/flate \
 	crypto/aes \
+	crypto/des \
 	crypto/hmac \
 	debug/dwarf \
 	debug/plan9obj \
@@ -405,17 +394,48 @@ TEST_PACKAGES_LINUX := \
 
 TEST_PACKAGES_DARWIN := $(TEST_PACKAGES_LINUX)
 
+# os/user requires t.Skip() support
 TEST_PACKAGES_WINDOWS := \
 	compress/flate \
+	crypto/des \
 	crypto/hmac \
-	os/user \
 	strconv \
 	text/template/parse \
 	$(nil)
 
+
+# These packages cannot be tested on wasm, mostly because these tests assume a
+# working filesystem. This could perhaps be fixed, by supporting filesystem
+# access when running inside Node.js.
+TEST_PACKAGES_WASM = $(filter-out $(TEST_PACKAGES_NONWASM), $(TEST_PACKAGES_FAST))
+TEST_PACKAGES_NONWASM = \
+	compress/lzw \
+	compress/zlib \
+	crypto/ecdsa \
+	debug/macho \
+	embed/internal/embedtest \
+	go/format \
+	os \
+	testing \
+	$(nil)
+
+# These packages cannot be tested on baremetal.
+#
+# Some reasons why the tests don't pass on baremetal:
+#
+#   * No filesystem is available, so packages like compress/zlib can't be tested
+#     (just like wasm).
+#   * picolibc math functions apparently are less precise, the math package
+#     fails on baremetal.
+TEST_PACKAGES_BAREMETAL = $(filter-out $(TEST_PACKAGES_NONBAREMETAL), $(TEST_PACKAGES_FAST))
+TEST_PACKAGES_NONBAREMETAL = \
+	$(TEST_PACKAGES_NONWASM) \
+	math \
+	$(nil)
+
 # Report platforms on which each standard library package is known to pass tests
-jointmp := $(shell echo /tmp/join.$$$$)
 report-stdlib-tests-pass:
+	$(eval jointmp := $(shell echo /tmp/join.$$$$))
 	@for t in $(TEST_PACKAGES_DARWIN); do echo "$$t darwin"; done | sort > $(jointmp).darwin
 	@for t in $(TEST_PACKAGES_LINUX); do echo "$$t linux"; done | sort > $(jointmp).linux
 	@for t in $(TEST_PACKAGES_FAST) $(TEST_PACKAGES_SLOW); do echo "$$t darwin linux wasi windows"; done | sort > $(jointmp).portable
@@ -424,11 +444,11 @@ report-stdlib-tests-pass:
 	@rm $(jointmp).*
 
 # Standard library packages that pass tests quickly on the current platform
-ifeq ($(shell uname),Darwin)
+ifeq ($(uname),Darwin)
 TEST_PACKAGES_HOST := $(TEST_PACKAGES_FAST) $(TEST_PACKAGES_DARWIN)
 TEST_IOFS := true
 endif
-ifeq ($(shell uname),Linux)
+ifeq ($(uname),Linux)
 TEST_PACKAGES_HOST := $(TEST_PACKAGES_FAST) $(TEST_PACKAGES_LINUX)
 TEST_IOFS := true
 endif
@@ -456,6 +476,8 @@ tinygo-bench-fast:
 	$(TINYGO) test -bench . $(TEST_PACKAGES_HOST)
 
 # Same thing, except for wasi rather than the current platform.
+tinygo-test-wasm:
+	$(TINYGO) test -target wasm $(TEST_PACKAGES_WASM)
 tinygo-test-wasi:
 	$(TINYGO) test -target wasip1 $(TEST_PACKAGES_FAST) $(TEST_PACKAGES_SLOW) ./tests/runtime_wasi
 tinygo-test-wasip1:
@@ -490,18 +512,19 @@ tinygo-bench-wasip2:
 tinygo-bench-wasip2-fast:
 	$(TINYGO) test -target wasip2 -bench . $(TEST_PACKAGES_FAST)
 
+# Run tests on riscv-qemu since that one provides a large amount of memory.
+tinygo-test-baremetal:
+	$(TINYGO) test -target riscv-qemu $(TEST_PACKAGES_BAREMETAL)
+
 # Test external packages in a large corpus.
 test-corpus:
 	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) test $(GOTESTFLAGS) -timeout=1h -buildmode exe -tags byollvm -run TestCorpus . -corpus=testdata/corpus.yaml
 test-corpus-fast:
 	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) test $(GOTESTFLAGS) -timeout=1h -buildmode exe -tags byollvm -run TestCorpus -short . -corpus=testdata/corpus.yaml
-test-corpus-wasi: wasi-libc
+test-corpus-wasi:
 	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) test $(GOTESTFLAGS) -timeout=1h -buildmode exe -tags byollvm -run TestCorpus . -corpus=testdata/corpus.yaml -target=wasip1
-
-tinygo-baremetal:
-	# Regression tests that run on a baremetal target and don't fit in either main_test.go or smoketest.
-	# regression test for #2666: e.g. encoding/hex must pass on baremetal
-	$(TINYGO) test -target cortex-m-qemu encoding/hex
+test-corpus-wasip2:
+	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) test $(GOTESTFLAGS) -timeout=1h -buildmode exe -tags byollvm -run TestCorpus . -corpus=testdata/corpus.yaml -target=wasip2
 
 .PHONY: testchdir
 testchdir:
@@ -573,21 +596,23 @@ smoketest: testchdir
 	@$(MD5SUM) test.hex
 	# test simulated boards on play.tinygo.org
 ifneq ($(WASM), 0)
-	$(TINYGO) build -size short -o test.wasm -tags=arduino              examples/blinky1
+	GOOS=js GOARCH=wasm $(TINYGO) build -size short -o test.wasm -tags=arduino              examples/blinky1
 	@$(MD5SUM) test.wasm
-	$(TINYGO) build -size short -o test.wasm -tags=hifive1b             examples/blinky1
+	GOOS=js GOARCH=wasm $(TINYGO) build -size short -o test.wasm -tags=hifive1b             examples/blinky1
 	@$(MD5SUM) test.wasm
-	$(TINYGO) build -size short -o test.wasm -tags=reelboard            examples/blinky1
+	GOOS=js GOARCH=wasm $(TINYGO) build -size short -o test.wasm -tags=reelboard            examples/blinky1
 	@$(MD5SUM) test.wasm
-	$(TINYGO) build -size short -o test.wasm -tags=microbit             examples/microbit-blink
+	GOOS=js GOARCH=wasm $(TINYGO) build -size short -o test.wasm -tags=microbit             examples/microbit-blink
 	@$(MD5SUM) test.wasm
-	$(TINYGO) build -size short -o test.wasm -tags=circuitplay_express  examples/blinky1
+	GOOS=js GOARCH=wasm $(TINYGO) build -size short -o test.wasm -tags=circuitplay_express  examples/blinky1
 	@$(MD5SUM) test.wasm
-	$(TINYGO) build -size short -o test.wasm -tags=circuitplay_bluefruit examples/blinky1
+	GOOS=js GOARCH=wasm $(TINYGO) build -size short -o test.wasm -tags=circuitplay_bluefruit examples/blinky1
 	@$(MD5SUM) test.wasm
-	$(TINYGO) build -size short -o test.wasm -tags=mch2022              examples/machinetest
+	GOOS=js GOARCH=wasm $(TINYGO) build -size short -o test.wasm -tags=mch2022              examples/machinetest
 	@$(MD5SUM) test.wasm
-	$(TINYGO) build -size short -o test.wasm -tags=gopher_badge         examples/blinky1
+	GOOS=js GOARCH=wasm $(TINYGO) build -size short -o test.wasm -tags=gopher_badge         examples/blinky1
+	@$(MD5SUM) test.wasm
+	GOOS=js GOARCH=wasm $(TINYGO) build -size short -o test.wasm -tags=pico                 examples/blinky1
 	@$(MD5SUM) test.wasm
 endif
 	# test all targets/boards
@@ -909,8 +934,9 @@ endif
 wasmtest:
 	$(GO) test ./tests/wasm
 
-build/release: tinygo gen-device wasi-libc $(if $(filter 1,$(USE_SYSTEM_BINARYEN)),,binaryen)
+build/release: tinygo gen-device $(if $(filter 1,$(USE_SYSTEM_BINARYEN)),,binaryen)
 	@mkdir -p build/release/tinygo/bin
+	@mkdir -p build/release/tinygo/lib/bdwgc
 	@mkdir -p build/release/tinygo/lib/clang/include
 	@mkdir -p build/release/tinygo/lib/CMSIS/CMSIS
 	@mkdir -p build/release/tinygo/lib/macos-minimal-sdk
@@ -923,7 +949,7 @@ build/release: tinygo gen-device wasi-libc $(if $(filter 1,$(USE_SYSTEM_BINARYEN
 	@mkdir -p build/release/tinygo/lib/nrfx
 	@mkdir -p build/release/tinygo/lib/picolibc/newlib/libc
 	@mkdir -p build/release/tinygo/lib/picolibc/newlib/libm
-	@mkdir -p build/release/tinygo/lib/wasi-libc/libc-bottom-half/headers
+	@mkdir -p build/release/tinygo/lib/wasi-libc/libc-bottom-half
 	@mkdir -p build/release/tinygo/lib/wasi-libc/libc-top-half/musl/arch
 	@mkdir -p build/release/tinygo/lib/wasi-libc/libc-top-half/musl/src
 	@mkdir -p build/release/tinygo/lib/wasi-cli/
@@ -932,6 +958,7 @@ build/release: tinygo gen-device wasi-libc $(if $(filter 1,$(USE_SYSTEM_BINARYEN
 ifneq ($(USE_SYSTEM_BINARYEN),1)
 	@cp -p  build/wasm-opt$(EXE)         build/release/tinygo/bin
 endif
+	@cp -rp lib/bdwgc/*                  build/release/tinygo/lib/bdwgc
 	@cp -p $(abspath $(CLANG_SRC))/lib/Headers/*.h build/release/tinygo/lib/clang/include
 	@cp -rp lib/CMSIS/CMSIS/Include      build/release/tinygo/lib/CMSIS/CMSIS
 	@cp -rp lib/CMSIS/README.md          build/release/tinygo/lib/CMSIS
@@ -945,6 +972,8 @@ endif
 	@cp -rp lib/musl/crt/crt1.c          build/release/tinygo/lib/musl/crt
 	@cp -rp lib/musl/COPYRIGHT           build/release/tinygo/lib/musl
 	@cp -rp lib/musl/include             build/release/tinygo/lib/musl
+	@cp -rp lib/musl/src/conf            build/release/tinygo/lib/musl/src
+	@cp -rp lib/musl/src/ctype           build/release/tinygo/lib/musl/src
 	@cp -rp lib/musl/src/env             build/release/tinygo/lib/musl/src
 	@cp -rp lib/musl/src/errno           build/release/tinygo/lib/musl/src
 	@cp -rp lib/musl/src/exit            build/release/tinygo/lib/musl/src
@@ -959,8 +988,10 @@ endif
 	@cp -rp lib/musl/src/math            build/release/tinygo/lib/musl/src
 	@cp -rp lib/musl/src/misc            build/release/tinygo/lib/musl/src
 	@cp -rp lib/musl/src/multibyte       build/release/tinygo/lib/musl/src
+	@cp -rp lib/musl/src/sched           build/release/tinygo/lib/musl/src
 	@cp -rp lib/musl/src/signal          build/release/tinygo/lib/musl/src
 	@cp -rp lib/musl/src/stdio           build/release/tinygo/lib/musl/src
+	@cp -rp lib/musl/src/stdlib          build/release/tinygo/lib/musl/src
 	@cp -rp lib/musl/src/string          build/release/tinygo/lib/musl/src
 	@cp -rp lib/musl/src/thread          build/release/tinygo/lib/musl/src
 	@cp -rp lib/musl/src/time            build/release/tinygo/lib/musl/src
@@ -972,6 +1003,7 @@ endif
 	@cp -rp lib/mingw-w64/mingw-w64-crt/stdio/ucrt_*                build/release/tinygo/lib/mingw-w64/mingw-w64-crt/stdio
 	@cp -rp lib/mingw-w64/mingw-w64-headers/crt/                    build/release/tinygo/lib/mingw-w64/mingw-w64-headers
 	@cp -rp lib/mingw-w64/mingw-w64-headers/defaults/include        build/release/tinygo/lib/mingw-w64/mingw-w64-headers/defaults
+	@cp -rp lib/mingw-w64/mingw-w64-headers/include                 build/release/tinygo/lib/mingw-w64/mingw-w64-headers
 	@cp -rp lib/nrfx/*                   build/release/tinygo/lib/nrfx
 	@cp -rp lib/picolibc/newlib/libc/ctype       build/release/tinygo/lib/picolibc/newlib/libc
 	@cp -rp lib/picolibc/newlib/libc/include     build/release/tinygo/lib/picolibc/newlib/libc
@@ -981,15 +1013,36 @@ endif
 	@cp -rp lib/picolibc/newlib/libm/common      build/release/tinygo/lib/picolibc/newlib/libm
 	@cp -rp lib/picolibc/newlib/libm/math        build/release/tinygo/lib/picolibc/newlib/libm
 	@cp -rp lib/picolibc-stdio.c         build/release/tinygo/lib
-	@cp -rp lib/wasi-libc/libc-bottom-half/headers/public           build/release/tinygo/lib/wasi-libc/libc-bottom-half/headers
+	@cp -rp lib/wasi-libc/libc-bottom-half/cloudlibc                build/release/tinygo/lib/wasi-libc/libc-bottom-half
+	@cp -rp lib/wasi-libc/libc-bottom-half/headers                  build/release/tinygo/lib/wasi-libc/libc-bottom-half
+	@cp -rp lib/wasi-libc/libc-bottom-half/sources                  build/release/tinygo/lib/wasi-libc/libc-bottom-half
+	@cp -rp lib/wasi-libc/libc-top-half/headers                     build/release/tinygo/lib/wasi-libc/libc-top-half
 	@cp -rp lib/wasi-libc/libc-top-half/musl/arch/generic           build/release/tinygo/lib/wasi-libc/libc-top-half/musl/arch
 	@cp -rp lib/wasi-libc/libc-top-half/musl/arch/wasm32            build/release/tinygo/lib/wasi-libc/libc-top-half/musl/arch
+	@cp -rp lib/wasi-libc/libc-top-half/musl/include                build/release/tinygo/lib/wasi-libc/libc-top-half/musl
+	@cp -rp lib/wasi-libc/libc-top-half/musl/src/conf               build/release/tinygo/lib/wasi-libc/libc-top-half/musl/src
+	@cp -rp lib/wasi-libc/libc-top-half/musl/src/dirent             build/release/tinygo/lib/wasi-libc/libc-top-half/musl/src
+	@cp -rp lib/wasi-libc/libc-top-half/musl/src/env                build/release/tinygo/lib/wasi-libc/libc-top-half/musl/src
+	@cp -rp lib/wasi-libc/libc-top-half/musl/src/errno              build/release/tinygo/lib/wasi-libc/libc-top-half/musl/src
+	@cp -rp lib/wasi-libc/libc-top-half/musl/src/exit               build/release/tinygo/lib/wasi-libc/libc-top-half/musl/src
+	@cp -rp lib/wasi-libc/libc-top-half/musl/src/fcntl              build/release/tinygo/lib/wasi-libc/libc-top-half/musl/src
+	@cp -rp lib/wasi-libc/libc-top-half/musl/src/fenv               build/release/tinygo/lib/wasi-libc/libc-top-half/musl/src
 	@cp -rp lib/wasi-libc/libc-top-half/musl/src/include            build/release/tinygo/lib/wasi-libc/libc-top-half/musl/src
 	@cp -rp lib/wasi-libc/libc-top-half/musl/src/internal           build/release/tinygo/lib/wasi-libc/libc-top-half/musl/src
+	@cp -rp lib/wasi-libc/libc-top-half/musl/src/legacy             build/release/tinygo/lib/wasi-libc/libc-top-half/musl/src
+	@cp -rp lib/wasi-libc/libc-top-half/musl/src/locale             build/release/tinygo/lib/wasi-libc/libc-top-half/musl/src
 	@cp -rp lib/wasi-libc/libc-top-half/musl/src/math               build/release/tinygo/lib/wasi-libc/libc-top-half/musl/src
+	@cp -rp lib/wasi-libc/libc-top-half/musl/src/misc               build/release/tinygo/lib/wasi-libc/libc-top-half/musl/src
+	@cp -rp lib/wasi-libc/libc-top-half/musl/src/multibyte          build/release/tinygo/lib/wasi-libc/libc-top-half/musl/src
+	@cp -rp lib/wasi-libc/libc-top-half/musl/src/network            build/release/tinygo/lib/wasi-libc/libc-top-half/musl/src
+	@cp -rp lib/wasi-libc/libc-top-half/musl/src/stat               build/release/tinygo/lib/wasi-libc/libc-top-half/musl/src
+	@cp -rp lib/wasi-libc/libc-top-half/musl/src/stdio              build/release/tinygo/lib/wasi-libc/libc-top-half/musl/src
+	@cp -rp lib/wasi-libc/libc-top-half/musl/src/stdlib             build/release/tinygo/lib/wasi-libc/libc-top-half/musl/src
 	@cp -rp lib/wasi-libc/libc-top-half/musl/src/string             build/release/tinygo/lib/wasi-libc/libc-top-half/musl/src
-	@cp -rp lib/wasi-libc/libc-top-half/musl/include                build/release/tinygo/lib/wasi-libc/libc-top-half/musl
-	@cp -rp lib/wasi-libc/sysroot                                   build/release/tinygo/lib/wasi-libc/sysroot
+	@cp -rp lib/wasi-libc/libc-top-half/musl/src/thread             build/release/tinygo/lib/wasi-libc/libc-top-half/musl/src
+	@cp -rp lib/wasi-libc/libc-top-half/musl/src/time               build/release/tinygo/lib/wasi-libc/libc-top-half/musl/src
+	@cp -rp lib/wasi-libc/libc-top-half/musl/src/unistd             build/release/tinygo/lib/wasi-libc/libc-top-half/musl/src
+	@cp -rp lib/wasi-libc/libc-top-half/sources                     build/release/tinygo/lib/wasi-libc/libc-top-half
 	@cp -rp lib/wasi-cli/wit                                        build/release/tinygo/lib/wasi-cli/wit
 	@cp -rp llvm-project/compiler-rt/lib/builtins build/release/tinygo/lib/compiler-rt-builtins
 	@cp -rp llvm-project/compiler-rt/LICENSE.TXT  build/release/tinygo/lib/compiler-rt-builtins

LICENSE

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

README.md

@@ -48,20 +48,22 @@ Here is a small TinyGo program for use by a WASI host application:
 ```go
 package main
 
-//go:wasm-module yourmodulename
-//export add
+//go:wasmexport add
 func add(x, y uint32) uint32 {
 	return x + y
 }
-
-// main is required for the `wasip1` target, even if it isn't used.
-func main() {}
 ```
 
-This compiles the above TinyGo program for use on any WASI runtime:
+This compiles the above TinyGo program for use on any WASI Preview 1 runtime:
 
 ```shell
-tinygo build -o main.wasm -target=wasip1 main.go
+tinygo build -buildmode=c-shared -o add.wasm -target=wasip1 add.go
+```
+
+You can also use the same syntax as Go 1.24+:
+
+```shell
+GOARCH=wasip1 GOOS=wasm tinygo build -buildmode=c-shared -o add.wasm add.go
 ```
 
 ## Installation

builder/ar.go

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

builder/bdwgc.go

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

builder/build.go

@@ -14,7 +14,6 @@ import (
 	"fmt"
 	"go/types"
 	"hash/crc32"
-	"io/fs"
 	"math/bits"
 	"os"
 	"os/exec"
@@ -149,16 +148,17 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 	var libcDependencies []*compileJob
 	switch config.Target.Libc {
 	case "darwin-libSystem":
-		job := makeDarwinLibSystemJob(config, tmpdir)
-		libcDependencies = append(libcDependencies, job)
+		libcJob := makeDarwinLibSystemJob(config, tmpdir)
+		libcDependencies = append(libcDependencies, libcJob)
 	case "musl":
-		job, unlock, err := libMusl.load(config, tmpdir)
+		var unlock func()
+		libcJob, unlock, err := libMusl.load(config, tmpdir)
 		if err != nil {
 			return BuildResult{}, err
 		}
 		defer unlock()
-		libcDependencies = append(libcDependencies, dummyCompileJob(filepath.Join(filepath.Dir(job.result), "crt1.o")))
-		libcDependencies = append(libcDependencies, job)
+		libcDependencies = append(libcDependencies, dummyCompileJob(filepath.Join(filepath.Dir(libcJob.result), "crt1.o")))
+		libcDependencies = append(libcDependencies, libcJob)
 	case "picolibc":
 		libcJob, unlock, err := libPicolibc.load(config, tmpdir)
 		if err != nil {
@@ -167,11 +167,12 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 		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 BuildResult{}, errors.New("could not find wasi-libc, perhaps you need to run `make wasi-libc`?")
+		libcJob, unlock, err := libWasiLibc.load(config, tmpdir)
+		if err != nil {
+			return BuildResult{}, err
 		}
-		libcDependencies = append(libcDependencies, dummyCompileJob(path))
+		defer unlock()
+		libcDependencies = append(libcDependencies, libcJob)
 	case "wasmbuiltins":
 		libcJob, unlock, err := libWasmBuiltins.load(config, tmpdir)
 		if err != nil {
@@ -180,12 +181,12 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 		defer unlock()
 		libcDependencies = append(libcDependencies, libcJob)
 	case "mingw-w64":
-		job, unlock, err := libMinGW.load(config, tmpdir)
+		libcJob, unlock, err := libMinGW.load(config, tmpdir)
 		if err != nil {
 			return BuildResult{}, err
 		}
 		defer unlock()
-		libcDependencies = append(libcDependencies, job)
+		libcDependencies = append(libcDependencies, libcJob)
 		libcDependencies = append(libcDependencies, makeMinGWExtraLibs(tmpdir, config.GOARCH())...)
 	case "":
 		// no library specified, so nothing to do
@@ -213,6 +214,7 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 		MaxStackAlloc:      config.MaxStackAlloc(),
 		NeedsStackObjects:  config.NeedsStackObjects(),
 		Debug:              !config.Options.SkipDWARF, // emit DWARF except when -internal-nodwarf is passed
+		Nobounds:           config.Options.Nobounds,
 		PanicStrategy:      config.PanicStrategy(),
 	}
 
@@ -449,8 +451,15 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 					if global.IsNil() {
 						return errors.New("global not found: " + globalName)
 					}
+					globalType := global.GlobalValueType()
+					if globalType.TypeKind() != llvm.StructTypeKind || globalType.StructName() != "runtime._string" {
+						// Verify this is indeed a string. This is needed so
+						// that makeGlobalsModule can just create the right
+						// globals of string type without checking.
+						return fmt.Errorf("%s: not a string", globalName)
+					}
 					name := global.Name()
-					newGlobal := llvm.AddGlobal(mod, global.GlobalValueType(), name+".tmp")
+					newGlobal := llvm.AddGlobal(mod, globalType, name+".tmp")
 					global.ReplaceAllUsesWith(newGlobal)
 					global.EraseFromParentAsGlobal()
 					newGlobal.SetName(name)
@@ -538,6 +547,15 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 				}
 			}
 
+			// Insert values from -ldflags="-X ..." into the IR.
+			// This is a separate module, so that the "runtime._string" type
+			// doesn't need to match precisely. LLVM tends to rename that type
+			// sometimes, leading to errors. But linking in a separate module
+			// works fine. See:
+			// https://github.com/tinygo-org/tinygo/issues/4810
+			globalsMod := makeGlobalsModule(ctx, globalValues, machine)
+			llvm.LinkModules(mod, globalsMod)
+
 			// Create runtime.initAll function that calls the runtime
 			// initializer of each package.
 			llvmInitFn := mod.NamedFunction("runtime.initAll")
@@ -590,7 +608,7 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 
 			// Run all optimization passes, which are much more effective now
 			// that the optimizer can see the whole program at once.
-			err := optimizeProgram(mod, config, globalValues)
+			err := optimizeProgram(mod, config)
 			if err != nil {
 				return err
 			}
@@ -693,6 +711,16 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 		linkerDependencies = append(linkerDependencies, job)
 	}
 
+	// The Boehm collector is stored in a separate C library.
+	if config.GC() == "boehm" {
+		job, unlock, err := BoehmGC.load(config, tmpdir)
+		if err != nil {
+			return BuildResult{}, err
+		}
+		defer unlock()
+		linkerDependencies = append(linkerDependencies, job)
+	}
+
 	// Add jobs to compile extra files. These files are in C or assembly and
 	// contain things like the interrupt vector table and low level operations
 	// such as stack switching.
@@ -1145,7 +1173,7 @@ func createEmbedObjectFile(data, hexSum, sourceFile, sourceDir, tmpdir string, c
 // optimizeProgram runs a series of optimizations and transformations that are
 // needed to convert a program to its final form. Some transformations are not
 // optional and must be run as the compiler expects them to run.
-func optimizeProgram(mod llvm.Module, config *compileopts.Config, globalValues map[string]map[string]string) error {
+func optimizeProgram(mod llvm.Module, config *compileopts.Config) error {
 	err := interp.Run(mod, config.Options.InterpTimeout, config.DumpSSA())
 	if err != nil {
 		return err
@@ -1163,12 +1191,6 @@ func optimizeProgram(mod llvm.Module, config *compileopts.Config, globalValues m
 		}
 	}
 
-	// Insert values from -ldflags="-X ..." into the IR.
-	err = setGlobalValues(mod, globalValues)
-	if err != nil {
-		return err
-	}
-
 	// Run most of the whole-program optimizations (including the whole
 	// O0/O1/O2/Os/Oz optimization pipeline).
 	errs := transform.Optimize(mod, config)
@@ -1182,10 +1204,19 @@ func optimizeProgram(mod llvm.Module, config *compileopts.Config, globalValues m
 	return nil
 }
 
-// setGlobalValues sets the global values from the -ldflags="-X ..." compiler
-// option in the given module. An error may be returned if the global is not of
-// the expected type.
-func setGlobalValues(mod llvm.Module, globals map[string]map[string]string) error {
+func makeGlobalsModule(ctx llvm.Context, globals map[string]map[string]string, machine llvm.TargetMachine) llvm.Module {
+	mod := ctx.NewModule("cmdline-globals")
+	targetData := machine.CreateTargetData()
+	defer targetData.Dispose()
+	mod.SetDataLayout(targetData.String())
+
+	stringType := ctx.StructCreateNamed("runtime._string")
+	uintptrType := ctx.IntType(targetData.PointerSize() * 8)
+	stringType.StructSetBody([]llvm.Type{
+		llvm.PointerType(ctx.Int8Type(), 0),
+		uintptrType,
+	}, false)
+
 	var pkgPaths []string
 	for pkgPath := range globals {
 		pkgPaths = append(pkgPaths, pkgPath)
@@ -1201,24 +1232,6 @@ func setGlobalValues(mod llvm.Module, globals map[string]map[string]string) erro
 		for _, name := range names {
 			value := pkg[name]
 			globalName := pkgPath + "." + name
-			global := mod.NamedGlobal(globalName)
-			if global.IsNil() || !global.Initializer().IsNil() {
-				// The global either does not exist (optimized away?) or has
-				// some value, in which case it has already been initialized at
-				// package init time.
-				continue
-			}
-
-			// A strin is a {ptr, len} pair. We need these types to build the
-			// initializer.
-			initializerType := global.GlobalValueType()
-			if initializerType.TypeKind() != llvm.StructTypeKind || initializerType.StructName() == "" {
-				return fmt.Errorf("%s: not a string", globalName)
-			}
-			elementTypes := initializerType.StructElementTypes()
-			if len(elementTypes) != 2 {
-				return fmt.Errorf("%s: not a string", globalName)
-			}
 
 			// Create a buffer for the string contents.
 			bufInitializer := mod.Context().ConstString(value, false)
@@ -1229,22 +1242,20 @@ func setGlobalValues(mod llvm.Module, globals map[string]map[string]string) erro
 			buf.SetLinkage(llvm.PrivateLinkage)
 
 			// Create the string value, which is a {ptr, len} pair.
-			zero := llvm.ConstInt(mod.Context().Int32Type(), 0, false)
-			ptr := llvm.ConstGEP(bufInitializer.Type(), buf, []llvm.Value{zero, zero})
-			if ptr.Type() != elementTypes[0] {
-				return fmt.Errorf("%s: not a string", globalName)
-			}
-			length := llvm.ConstInt(elementTypes[1], uint64(len(value)), false)
-			initializer := llvm.ConstNamedStruct(initializerType, []llvm.Value{
-				ptr,
+			length := llvm.ConstInt(uintptrType, uint64(len(value)), false)
+			initializer := llvm.ConstNamedStruct(stringType, []llvm.Value{
+				buf,
 				length,
 			})
 
-			// Set the initializer. No initializer should be set at this point.
+			// Create the string global.
+			global := llvm.AddGlobal(mod, stringType, globalName)
 			global.SetInitializer(initializer)
+			global.SetAlignment(targetData.PrefTypeAlignment(stringType))
 		}
 	}
-	return nil
+
+	return mod
 }
 
 // functionStackSizes keeps stack size information about a single function

builder/builder_test.go

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

builder/config.go

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

builder/library.go

@@ -15,6 +15,9 @@ import (
 
 // Library is a container for information about a single C library, such as a
 // compiler runtime or libc.
+//
+// Note: whenever a library gets changed, the version in compileopts/config.go
+// probably also needs to be incremented.
 type Library struct {
 	// The library name, such as compiler-rt or picolibc.
 	name string
@@ -25,6 +28,12 @@ type Library struct {
 	// cflags returns the C flags specific to this library
 	cflags func(target, headerPath string) []string
 
+	// cflagsForFile returns additional C flags for a particular source file.
+	cflagsForFile func(path string) []string
+
+	// needsLibc is set to true if this library needs libc headers.
+	needsLibc bool
+
 	// The source directory.
 	sourceDir func() string
 
@@ -44,13 +53,8 @@ type Library struct {
 // As a side effect, this call creates the library header files if they didn't
 // exist yet.
 func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJob, abortLock func(), err error) {
-	outdir, precompiled := config.LibcPath(l.name)
+	outdir := config.LibraryPath(l.name)
 	archiveFilePath := filepath.Join(outdir, "lib.a")
-	if precompiled {
-		// Found a precompiled library for this OS/architecture. Return the path
-		// directly.
-		return dummyCompileJob(archiveFilePath), func() {}, nil
-	}
 
 	// Create a lock on the output (if supported).
 	// This is a bit messy, but avoids a deadlock because it is ordered consistently with other library loads within a build.
@@ -181,6 +185,9 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 			args = append(args, "-mfpu=vfpv2")
 		}
 	}
+	if l.needsLibc {
+		args = append(args, config.LibcCFlags()...)
+	}
 
 	var once sync.Once
 
@@ -225,6 +232,7 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 	}
 	for _, path := range paths {
 		// Strip leading "../" parts off the path.
+		path := path
 		cleanpath := path
 		for strings.HasPrefix(cleanpath, "../") {
 			cleanpath = cleanpath[3:]
@@ -233,11 +241,14 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 		objpath := filepath.Join(dir, cleanpath+".o")
 		os.MkdirAll(filepath.Dir(objpath), 0o777)
 		objs = append(objs, objpath)
-		job.dependencies = append(job.dependencies, &compileJob{
+		objfile := &compileJob{
 			description: "compile " + srcpath,
 			run: func(*compileJob) error {
 				var compileArgs []string
 				compileArgs = append(compileArgs, args...)
+				if l.cflagsForFile != nil {
+					compileArgs = append(compileArgs, l.cflagsForFile(path)...)
+				}
 				compileArgs = append(compileArgs, "-o", objpath, srcpath)
 				if config.Options.PrintCommands != nil {
 					config.Options.PrintCommands("clang", compileArgs...)
@@ -248,7 +259,8 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 				}
 				return nil
 			},
-		})
+		}
+		job.dependencies = append(job.dependencies, objfile)
 	}
 
 	// Create crt1.o job, if needed.
@@ -257,7 +269,7 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 	// won't make much of a difference in speed).
 	if l.crt1Source != "" {
 		srcpath := filepath.Join(sourceDir, l.crt1Source)
-		job.dependencies = append(job.dependencies, &compileJob{
+		crt1Job := &compileJob{
 			description: "compile " + srcpath,
 			run: func(*compileJob) error {
 				var compileArgs []string
@@ -277,7 +289,8 @@ func (l *Library) load(config *compileopts.Config, tmpdir string) (job *compileJ
 				}
 				return os.Rename(tmpfile.Name(), filepath.Join(outdir, "crt1.o"))
 			},
-		})
+		}
+		job.dependencies = append(job.dependencies, crt1Job)
 	}
 
 	ok = true

builder/musl.go

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

builder/sizes_test.go

@@ -43,8 +43,8 @@ func TestBinarySize(t *testing.T) {
 	tests := []sizeTest{
 		// microcontrollers
 		{"hifive1b", "examples/echo", 4560, 280, 0, 2268},
-		{"microbit", "examples/serial", 2916, 388, 8, 2272},
-		{"wioterminal", "examples/pininterrupt", 7315, 1489, 116, 6912},
+		{"microbit", "examples/serial", 2924, 388, 8, 2272},
+		{"wioterminal", "examples/pininterrupt", 7383, 1489, 116, 6912},
 
 		// TODO: also check wasm. Right now this is difficult, because
 		// wasm binaries are run through wasm-opt and therefore the

builder/wasilibc.go

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

cgo/cgo.go

@@ -92,18 +92,18 @@ type noescapingFunc struct {
 // cgoAliases list type aliases between Go and C, for types that are equivalent
 // in both languages. See addTypeAliases.
 var cgoAliases = map[string]string{
-	"C.int8_t":    "int8",
-	"C.int16_t":   "int16",
-	"C.int32_t":   "int32",
-	"C.int64_t":   "int64",
-	"C.uint8_t":   "uint8",
-	"C.uint16_t":  "uint16",
-	"C.uint32_t":  "uint32",
-	"C.uint64_t":  "uint64",
-	"C.uintptr_t": "uintptr",
-	"C.float":     "float32",
-	"C.double":    "float64",
-	"C._Bool":     "bool",
+	"_Cgo_int8_t":    "int8",
+	"_Cgo_int16_t":   "int16",
+	"_Cgo_int32_t":   "int32",
+	"_Cgo_int64_t":   "int64",
+	"_Cgo_uint8_t":   "uint8",
+	"_Cgo_uint16_t":  "uint16",
+	"_Cgo_uint32_t":  "uint32",
+	"_Cgo_uint64_t":  "uint64",
+	"_Cgo_uintptr_t": "uintptr",
+	"_Cgo_float":     "float32",
+	"_Cgo_double":    "float64",
+	"_Cgo__Bool":     "bool",
 }
 
 // builtinAliases are handled specially because they only exist on the Go side
@@ -145,48 +145,46 @@ typedef unsigned long long  _Cgo_ulonglong;
 // The string/bytes functions below implement C.CString etc. To make sure the
 // runtime doesn't need to know the C int type, lengths are converted to uintptr
 // first.
-// These functions will be modified to get a "C." prefix, so the source below
-// doesn't reflect the final AST.
 const generatedGoFilePrefixBase = `
 import "syscall"
 import "unsafe"
 
 var _ unsafe.Pointer
 
-//go:linkname C.CString runtime.cgo_CString
-func CString(string) *C.char
+//go:linkname _Cgo_CString runtime.cgo_CString
+func _Cgo_CString(string) *_Cgo_char
 
-//go:linkname C.GoString runtime.cgo_GoString
-func GoString(*C.char) string
+//go:linkname _Cgo_GoString runtime.cgo_GoString
+func _Cgo_GoString(*_Cgo_char) string
 
-//go:linkname C.__GoStringN runtime.cgo_GoStringN
-func __GoStringN(*C.char, uintptr) string
+//go:linkname _Cgo___GoStringN runtime.cgo_GoStringN
+func _Cgo___GoStringN(*_Cgo_char, uintptr) string
 
-func GoStringN(cstr *C.char, length C.int) string {
-	return C.__GoStringN(cstr, uintptr(length))
+func _Cgo_GoStringN(cstr *_Cgo_char, length _Cgo_int) string {
+	return _Cgo___GoStringN(cstr, uintptr(length))
 }
 
-//go:linkname C.__GoBytes runtime.cgo_GoBytes
-func __GoBytes(unsafe.Pointer, uintptr) []byte
+//go:linkname _Cgo___GoBytes runtime.cgo_GoBytes
+func _Cgo___GoBytes(unsafe.Pointer, uintptr) []byte
 
-func GoBytes(ptr unsafe.Pointer, length C.int) []byte {
-	return C.__GoBytes(ptr, uintptr(length))
+func _Cgo_GoBytes(ptr unsafe.Pointer, length _Cgo_int) []byte {
+	return _Cgo___GoBytes(ptr, uintptr(length))
 }
 
-//go:linkname C.__CBytes runtime.cgo_CBytes
-func __CBytes([]byte) unsafe.Pointer
+//go:linkname _Cgo___CBytes runtime.cgo_CBytes
+func _Cgo___CBytes([]byte) unsafe.Pointer
 
-func CBytes(b []byte) unsafe.Pointer {
-	return C.__CBytes(b)
+func _Cgo_CBytes(b []byte) unsafe.Pointer {
+	return _Cgo___CBytes(b)
 }
 
-//go:linkname C.__get_errno_num runtime.cgo_errno
-func __get_errno_num() uintptr
+//go:linkname _Cgo___get_errno_num runtime.cgo_errno
+func _Cgo___get_errno_num() uintptr
 `
 
 const generatedGoFilePrefixOther = generatedGoFilePrefixBase + `
-func __get_errno() error {
-	return syscall.Errno(C.__get_errno_num())
+func _Cgo___get_errno() error {
+	return syscall.Errno(_Cgo___get_errno_num())
 }
 `
 
@@ -197,7 +195,7 @@ func __get_errno() error {
 // map the errno values to match the values in the syscall package.
 // Source of the errno values: lib/mingw-w64/mingw-w64-headers/crt/errno.h
 const generatedGoFilePrefixWindows = generatedGoFilePrefixBase + `
-var __errno_mapping = [...]syscall.Errno{
+var _Cgo___errno_mapping = [...]syscall.Errno{
 	1:  syscall.EPERM,
 	2:  syscall.ENOENT,
 	3:  syscall.ESRCH,
@@ -238,10 +236,10 @@ var __errno_mapping = [...]syscall.Errno{
 	42: syscall.EILSEQ,
 }
 
-func __get_errno() error {
-	num := C.__get_errno_num()
-	if num < uintptr(len(__errno_mapping)) {
-		if mapped := __errno_mapping[num]; mapped != 0 {
+func _Cgo___get_errno() error {
+	num := _Cgo___get_errno_num()
+	if num < uintptr(len(_Cgo___errno_mapping)) {
+		if mapped := _Cgo___errno_mapping[num]; mapped != 0 {
 			return mapped
 		}
 	}
@@ -304,23 +302,6 @@ func Process(files []*ast.File, dir, importPath string, fset *token.FileSet, cfl
 	// If the Comments field is not set to nil, the go/format package will get
 	// confused about where comments should go.
 	p.generated.Comments = nil
-	// Adjust some of the functions in there.
-	for _, decl := range p.generated.Decls {
-		switch decl := decl.(type) {
-		case *ast.FuncDecl:
-			switch decl.Name.Name {
-			case "CString", "GoString", "GoStringN", "__GoStringN", "GoBytes", "__GoBytes", "CBytes", "__CBytes", "__get_errno_num", "__get_errno", "__errno_mapping":
-				// Adjust the name to have a "C." prefix so it is correctly
-				// resolved.
-				decl.Name.Name = "C." + decl.Name.Name
-			}
-		}
-	}
-	// Patch some types, for example *C.char in C.CString.
-	cf := p.newCGoFile(nil, -1) // dummy *cgoFile for the walker
-	astutil.Apply(p.generated, func(cursor *astutil.Cursor) bool {
-		return cf.walker(cursor, nil)
-	}, nil)
 
 	// Find `import "C"` C fragments in the file.
 	p.cgoHeaders = make([]string, len(files)) // combined CGo header fragment for each file
@@ -399,7 +380,7 @@ func Process(files []*ast.File, dir, importPath string, fset *token.FileSet, cfl
 			Tok:    token.TYPE,
 		}
 		for _, name := range builtinAliases {
-			typeSpec := p.getIntegerType("C."+name, names["_Cgo_"+name])
+			typeSpec := p.getIntegerType("_Cgo_"+name, names["_Cgo_"+name])
 			gen.Specs = append(gen.Specs, typeSpec)
 		}
 		p.generated.Decls = append(p.generated.Decls, gen)
@@ -1272,7 +1253,7 @@ func (p *cgoPackage) getUnnamedDeclName(prefix string, itf interface{}) string {
 func (f *cgoFile) getASTDeclName(name string, found clangCursor, iscall bool) string {
 	// Some types are defined in stdint.h and map directly to a particular Go
 	// type.
-	if alias := cgoAliases["C."+name]; alias != "" {
+	if alias := cgoAliases["_Cgo_"+name]; alias != "" {
 		return alias
 	}
 	node := f.getASTDeclNode(name, found)
@@ -1282,7 +1263,7 @@ func (f *cgoFile) getASTDeclName(name string, found clangCursor, iscall bool) st
 		}
 		return node.Name.Name
 	}
-	return "C." + name
+	return "_Cgo_" + name
 }
 
 // getASTDeclNode will declare the given C AST node (if not already defined) and
@@ -1382,8 +1363,8 @@ extern __typeof(%s) %s __attribute__((alias(%#v)));
 	case *elaboratedTypeInfo:
 		// Add struct bitfields.
 		for _, bitfield := range elaboratedType.bitfields {
-			f.createBitfieldGetter(bitfield, "C."+name)
-			f.createBitfieldSetter(bitfield, "C."+name)
+			f.createBitfieldGetter(bitfield, "_Cgo_"+name)
+			f.createBitfieldSetter(bitfield, "_Cgo_"+name)
 		}
 		if elaboratedType.unionSize != 0 {
 			// Create union getters/setters.
@@ -1392,7 +1373,7 @@ extern __typeof(%s) %s __attribute__((alias(%#v)));
 					f.addError(elaboratedType.pos, fmt.Sprintf("union must have field with a single name, it has %d names", len(field.Names)))
 					continue
 				}
-				f.createUnionAccessor(field, "C."+name)
+				f.createUnionAccessor(field, "_Cgo_"+name)
 			}
 		}
 	}
@@ -1441,7 +1422,7 @@ func (f *cgoFile) walker(cursor *astutil.Cursor, names map[string]clangCursor) b
 			node.Rhs = append(node.Rhs, &ast.CallExpr{
 				Fun: &ast.Ident{
 					NamePos: node.Lhs[1].End(),
-					Name:    "C.__get_errno",
+					Name:    "_Cgo___get_errno",
 				},
 			})
 		}
@@ -1466,7 +1447,7 @@ func (f *cgoFile) walker(cursor *astutil.Cursor, names map[string]clangCursor) b
 			return true
 		}
 		if x.Name == "C" {
-			name := "C." + node.Sel.Name
+			name := "_Cgo_" + node.Sel.Name
 			if found, ok := names[node.Sel.Name]; ok {
 				name = f.getASTDeclName(node.Sel.Name, found, false)
 			}

cgo/libclang.go

@@ -71,7 +71,7 @@ unsigned tinygo_clang_Cursor_isMacroFunctionLike(GoCXCursor c);
 //     libclang.go:68:5: note: previous declaration is here
 // See: https://github.com/golang/go/issues/49721
 #if defined(_WIN32)
-#define CGO_DECL // __declspec(dllexport)
+#define CGO_DECL __declspec(dllexport)
 #else
 #define CGO_DECL
 #endif
@@ -219,7 +219,7 @@ func (f *cgoFile) createASTNode(name string, c clangCursor) (ast.Node, any) {
 		numArgs := int(C.tinygo_clang_Cursor_getNumArguments(c))
 		obj := &ast.Object{
 			Kind: ast.Fun,
-			Name: "C." + name,
+			Name: "_Cgo_" + name,
 		}
 		exportName := name
 		localName := name
@@ -257,7 +257,7 @@ func (f *cgoFile) createASTNode(name string, c clangCursor) (ast.Node, any) {
 			},
 			Name: &ast.Ident{
 				NamePos: pos,
-				Name:    "C." + localName,
+				Name:    "_Cgo_" + localName,
 				Obj:     obj,
 			},
 			Type: &ast.FuncType{
@@ -319,7 +319,7 @@ func (f *cgoFile) createASTNode(name string, c clangCursor) (ast.Node, any) {
 		return decl, stringSignature
 	case C.CXCursor_StructDecl, C.CXCursor_UnionDecl:
 		typ := f.makeASTRecordType(c, pos)
-		typeName := "C." + name
+		typeName := "_Cgo_" + name
 		typeExpr := typ.typeExpr
 		if typ.unionSize != 0 {
 			// Convert to a single-field struct type.
@@ -340,7 +340,7 @@ func (f *cgoFile) createASTNode(name string, c clangCursor) (ast.Node, any) {
 		obj.Decl = typeSpec
 		return typeSpec, typ
 	case C.CXCursor_TypedefDecl:
-		typeName := "C." + name
+		typeName := "_Cgo_" + name
 		underlyingType := C.tinygo_clang_getTypedefDeclUnderlyingType(c)
 		obj := &ast.Object{
 			Kind: ast.Typ,
@@ -378,12 +378,12 @@ func (f *cgoFile) createASTNode(name string, c clangCursor) (ast.Node, any) {
 		}
 		obj := &ast.Object{
 			Kind: ast.Var,
-			Name: "C." + name,
+			Name: "_Cgo_" + name,
 		}
 		valueSpec := &ast.ValueSpec{
 			Names: []*ast.Ident{{
 				NamePos: pos,
-				Name:    "C." + name,
+				Name:    "_Cgo_" + name,
 				Obj:     obj,
 			}},
 			Type: typeExpr,
@@ -407,12 +407,12 @@ func (f *cgoFile) createASTNode(name string, c clangCursor) (ast.Node, any) {
 		}
 		obj := &ast.Object{
 			Kind: ast.Con,
-			Name: "C." + name,
+			Name: "_Cgo_" + name,
 		}
 		valueSpec := &ast.ValueSpec{
 			Names: []*ast.Ident{{
 				NamePos: pos,
-				Name:    "C." + name,
+				Name:    "_Cgo_" + name,
 				Obj:     obj,
 			}},
 			Values: []ast.Expr{expr},
@@ -423,7 +423,7 @@ func (f *cgoFile) createASTNode(name string, c clangCursor) (ast.Node, any) {
 	case C.CXCursor_EnumDecl:
 		obj := &ast.Object{
 			Kind: ast.Typ,
-			Name: "C." + name,
+			Name: "_Cgo_" + name,
 		}
 		underlying := C.tinygo_clang_getEnumDeclIntegerType(c)
 		// TODO: gc's CGo implementation uses types such as `uint32` for enums
@@ -431,7 +431,7 @@ func (f *cgoFile) createASTNode(name string, c clangCursor) (ast.Node, any) {
 		typeSpec := &ast.TypeSpec{
 			Name: &ast.Ident{
 				NamePos: pos,
-				Name:    "C." + name,
+				Name:    "_Cgo_" + name,
 				Obj:     obj,
 			},
 			Assign: pos,
@@ -454,12 +454,12 @@ func (f *cgoFile) createASTNode(name string, c clangCursor) (ast.Node, any) {
 		}
 		obj := &ast.Object{
 			Kind: ast.Con,
-			Name: "C." + name,
+			Name: "_Cgo_" + name,
 		}
 		valueSpec := &ast.ValueSpec{
 			Names: []*ast.Ident{{
 				NamePos: pos,
-				Name:    "C." + name,
+				Name:    "_Cgo_" + name,
 				Obj:     obj,
 			}},
 			Values: []ast.Expr{expr},
@@ -745,27 +745,27 @@ func (f *cgoFile) makeASTType(typ C.CXType, pos token.Pos) ast.Expr {
 	var typeName string
 	switch typ.kind {
 	case C.CXType_Char_S, C.CXType_Char_U:
-		typeName = "C.char"
+		typeName = "_Cgo_char"
 	case C.CXType_SChar:
-		typeName = "C.schar"
+		typeName = "_Cgo_schar"
 	case C.CXType_UChar:
-		typeName = "C.uchar"
+		typeName = "_Cgo_uchar"
 	case C.CXType_Short:
-		typeName = "C.short"
+		typeName = "_Cgo_short"
 	case C.CXType_UShort:
-		typeName = "C.ushort"
+		typeName = "_Cgo_ushort"
 	case C.CXType_Int:
-		typeName = "C.int"
+		typeName = "_Cgo_int"
 	case C.CXType_UInt:
-		typeName = "C.uint"
+		typeName = "_Cgo_uint"
 	case C.CXType_Long:
-		typeName = "C.long"
+		typeName = "_Cgo_long"
 	case C.CXType_ULong:
-		typeName = "C.ulong"
+		typeName = "_Cgo_ulong"
 	case C.CXType_LongLong:
-		typeName = "C.longlong"
+		typeName = "_Cgo_longlong"
 	case C.CXType_ULongLong:
-		typeName = "C.ulonglong"
+		typeName = "_Cgo_ulonglong"
 	case C.CXType_Bool:
 		typeName = "bool"
 	case C.CXType_Float, C.CXType_Double, C.CXType_LongDouble:
@@ -896,7 +896,7 @@ func (f *cgoFile) makeASTType(typ C.CXType, pos token.Pos) ast.Expr {
 		typeSpelling := getString(C.clang_getTypeSpelling(typ))
 		typeKindSpelling := getString(C.clang_getTypeKindSpelling(typ.kind))
 		f.addError(pos, fmt.Sprintf("unknown C type: %v (libclang type kind %s)", typeSpelling, typeKindSpelling))
-		typeName = "C.<unknown>"
+		typeName = "_Cgo_<unknown>"
 	}
 	return &ast.Ident{
 		NamePos: pos,
@@ -913,7 +913,7 @@ func (p *cgoPackage) getIntegerType(name string, cursor clangCursor) *ast.TypeSp
 	var goName string
 	typeSize := C.clang_Type_getSizeOf(underlyingType)
 	switch name {
-	case "C.char":
+	case "_Cgo_char":
 		if typeSize != 1 {
 			// This happens for some very special purpose architectures
 			// (DSPs etc.) that are not currently targeted.
@@ -926,7 +926,7 @@ func (p *cgoPackage) getIntegerType(name string, cursor clangCursor) *ast.TypeSp
 		case C.CXType_Char_U:
 			goName = "uint8"
 		}
-	case "C.schar", "C.short", "C.int", "C.long", "C.longlong":
+	case "_Cgo_schar", "_Cgo_short", "_Cgo_int", "_Cgo_long", "_Cgo_longlong":
 		switch typeSize {
 		case 1:
 			goName = "int8"
@@ -937,7 +937,7 @@ func (p *cgoPackage) getIntegerType(name string, cursor clangCursor) *ast.TypeSp
 		case 8:
 			goName = "int64"
 		}
-	case "C.uchar", "C.ushort", "C.uint", "C.ulong", "C.ulonglong":
+	case "_Cgo_uchar", "_Cgo_ushort", "_Cgo_uint", "_Cgo_ulong", "_Cgo_ulonglong":
 		switch typeSize {
 		case 1:
 			goName = "uint8"

cgo/testdata/basic.out.go

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

cgo/testdata/const.out.go

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

cgo/testdata/errors.out.go

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

cgo/testdata/flags.out.go

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

cgo/testdata/symbols.out.go

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

cgo/testdata/types.out.go

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

compileopts/config.go

@@ -8,12 +8,23 @@ import (
 	"os"
 	"path/filepath"
 	"regexp"
+	"strconv"
 	"strings"
 
 	"github.com/google/shlex"
 	"github.com/tinygo-org/tinygo/goenv"
 )
 
+// Library versions. Whenever an existing library is changed, this number should
+// be added/increased so that existing caches are invalidated.
+//
+// (This is a bit of a layering violation, this should really be part of the
+// builder.Library struct but that's hard to do since we want to know the
+// library path in advance in several places).
+var libVersions = map[string]int{
+	"musl": 3,
+}
+
 // Config keeps all configuration affecting the build in a single struct.
 type Config struct {
 	Options        *Options
@@ -247,10 +258,9 @@ func MuslArchitecture(triple string) string {
 	return CanonicalArchName(triple)
 }
 
-// LibcPath returns the path to the libc directory. The libc path will be either
-// a precompiled libc shipped with a TinyGo build, or a libc path in the cache
-// directory (which might not yet be built).
-func (c *Config) LibcPath(name string) (path string, precompiled bool) {
+// LibraryPath returns the path to the library build directory. The path will be
+// a library path in the cache directory (which might not yet be built).
+func (c *Config) LibraryPath(name string) string {
 	archname := c.Triple()
 	if c.CPU() != "" {
 		archname += "-" + c.CPU()
@@ -261,18 +271,19 @@ func (c *Config) LibcPath(name string) (path string, precompiled bool) {
 	if c.Target.SoftFloat {
 		archname += "-softfloat"
 	}
+	if name == "bdwgc" {
+		// Boehm GC is compiled against a particular libc.
+		archname += "-" + c.Target.Libc
+	}
 
-	// Try to load a precompiled library.
-	precompiledDir := filepath.Join(goenv.Get("TINYGOROOT"), "pkg", archname, name)
-	if _, err := os.Stat(precompiledDir); err == nil {
-		// Found a precompiled library for this OS/architecture. Return the path
-		// directly.
-		return precompiledDir, true
+	// Append a version string, if this library has a version.
+	if v, ok := libVersions[name]; ok {
+		archname += "-v" + strconv.Itoa(v)
 	}
 
 	// No precompiled library found. Determine the path name that will be used
 	// in the build cache.
-	return filepath.Join(goenv.Get("GOCACHE"), name+"-"+archname), false
+	return filepath.Join(goenv.Get("GOCACHE"), name+"-"+archname)
 }
 
 // DefaultBinaryExtension returns the default extension for binaries, such as
@@ -315,59 +326,7 @@ func (c *Config) CFlags(libclang bool) []string {
 			"-resource-dir="+resourceDir,
 		)
 	}
-	switch c.Target.Libc {
-	case "darwin-libSystem":
-		root := goenv.Get("TINYGOROOT")
-		cflags = append(cflags,
-			"-nostdlibinc",
-			"-isystem", filepath.Join(root, "lib/macos-minimal-sdk/src/usr/include"),
-		)
-	case "picolibc":
-		root := goenv.Get("TINYGOROOT")
-		picolibcDir := filepath.Join(root, "lib", "picolibc", "newlib", "libc")
-		path, _ := c.LibcPath("picolibc")
-		cflags = append(cflags,
-			"-nostdlibinc",
-			"-isystem", filepath.Join(path, "include"),
-			"-isystem", filepath.Join(picolibcDir, "include"),
-			"-isystem", filepath.Join(picolibcDir, "tinystdio"),
-			"-D__PICOLIBC_ERRNO_FUNCTION=__errno_location",
-		)
-	case "musl":
-		root := goenv.Get("TINYGOROOT")
-		path, _ := c.LibcPath("musl")
-		arch := MuslArchitecture(c.Triple())
-		cflags = append(cflags,
-			"-nostdlibinc",
-			"-isystem", filepath.Join(path, "include"),
-			"-isystem", filepath.Join(root, "lib", "musl", "arch", arch),
-			"-isystem", filepath.Join(root, "lib", "musl", "arch", "generic"),
-			"-isystem", filepath.Join(root, "lib", "musl", "include"),
-		)
-	case "wasi-libc":
-		root := goenv.Get("TINYGOROOT")
-		cflags = append(cflags,
-			"-nostdlibinc",
-			"-isystem", root+"/lib/wasi-libc/sysroot/include")
-	case "wasmbuiltins":
-		// nothing to add (library is purely for builtins)
-	case "mingw-w64":
-		root := goenv.Get("TINYGOROOT")
-		path, _ := c.LibcPath("mingw-w64")
-		cflags = append(cflags,
-			"-nostdlibinc",
-			"-isystem", filepath.Join(path, "include"),
-			"-isystem", filepath.Join(root, "lib", "mingw-w64", "mingw-w64-headers", "crt"),
-			"-isystem", filepath.Join(root, "lib", "mingw-w64", "mingw-w64-headers", "defaults", "include"),
-			"-D_UCRT",
-		)
-	case "":
-		// No libc specified, nothing to add.
-	default:
-		// Incorrect configuration. This could be handled in a better way, but
-		// usually this will be found by developers (not by TinyGo users).
-		panic("unknown libc: " + c.Target.Libc)
-	}
+	cflags = append(cflags, c.LibcCFlags()...)
 	// Always emit debug information. It is optionally stripped at link time.
 	cflags = append(cflags, "-gdwarf-4")
 	// Use the same optimization level as TinyGo.
@@ -394,6 +353,70 @@ func (c *Config) CFlags(libclang bool) []string {
 	return cflags
 }
 
+// LibcCFlags returns the C compiler flags for the configured libc.
+// It only uses flags that are part of the libc path (triple, cpu, abi, libc
+// name) so it can safely be used to compile another C library.
+func (c *Config) LibcCFlags() []string {
+	switch c.Target.Libc {
+	case "darwin-libSystem":
+		root := goenv.Get("TINYGOROOT")
+		return []string{
+			"-nostdlibinc",
+			"-isystem", filepath.Join(root, "lib/macos-minimal-sdk/src/usr/include"),
+		}
+	case "picolibc":
+		root := goenv.Get("TINYGOROOT")
+		picolibcDir := filepath.Join(root, "lib", "picolibc", "newlib", "libc")
+		path := c.LibraryPath("picolibc")
+		return []string{
+			"-nostdlibinc",
+			"-isystem", filepath.Join(path, "include"),
+			"-isystem", filepath.Join(picolibcDir, "include"),
+			"-isystem", filepath.Join(picolibcDir, "tinystdio"),
+			"-D__PICOLIBC_ERRNO_FUNCTION=__errno_location",
+		}
+	case "musl":
+		root := goenv.Get("TINYGOROOT")
+		path := c.LibraryPath("musl")
+		arch := MuslArchitecture(c.Triple())
+		return []string{
+			"-nostdlibinc",
+			"-isystem", filepath.Join(path, "include"),
+			"-isystem", filepath.Join(root, "lib", "musl", "arch", arch),
+			"-isystem", filepath.Join(root, "lib", "musl", "arch", "generic"),
+			"-isystem", filepath.Join(root, "lib", "musl", "include"),
+		}
+	case "wasi-libc":
+		path := c.LibraryPath("wasi-libc")
+		return []string{
+			"-nostdlibinc",
+			"-isystem", filepath.Join(path, "include"),
+		}
+	case "wasmbuiltins":
+		// nothing to add (library is purely for builtins)
+		return nil
+	case "mingw-w64":
+		root := goenv.Get("TINYGOROOT")
+		path := c.LibraryPath("mingw-w64")
+		return []string{
+			"-nostdlibinc",
+			"-isystem", filepath.Join(path, "include"),
+			"-isystem", filepath.Join(root, "lib", "mingw-w64", "mingw-w64-headers", "crt"),
+			"-isystem", filepath.Join(root, "lib", "mingw-w64", "mingw-w64-headers", "include"),
+			"-isystem", filepath.Join(root, "lib", "mingw-w64", "mingw-w64-headers", "defaults", "include"),
+			"-D_UCRT",
+			"-D_WIN32_WINNT=0x0a00", // target Windows 10
+		}
+	case "":
+		// No libc specified, nothing to add.
+		return nil
+	default:
+		// Incorrect configuration. This could be handled in a better way, but
+		// usually this will be found by developers (not by TinyGo users).
+		panic("unknown libc: " + c.Target.Libc)
+	}
+}
+
 // LDFlags returns the flags to pass to the linker. A few more flags are needed
 // (like the one for the compiler runtime), but this represents the majority of
 // the flags.

compileopts/options.go

@@ -9,8 +9,8 @@ import (
 
 var (
 	validBuildModeOptions     = []string{"default", "c-shared", "wasi-legacy"}
-	validGCOptions            = []string{"none", "leaking", "conservative", "custom", "precise"}
-	validSchedulerOptions     = []string{"none", "tasks", "asyncify"}
+	validGCOptions            = []string{"none", "leaking", "conservative", "custom", "precise", "boehm"}
+	validSchedulerOptions     = []string{"none", "tasks", "asyncify", "threads"}
 	validSerialOptions        = []string{"none", "uart", "usb", "rtt"}
 	validPrintSizeOptions     = []string{"none", "short", "full", "html"}
 	validPanicStrategyOptions = []string{"print", "trap"}
@@ -43,6 +43,7 @@ type Options struct {
 	PrintCommands   func(cmd string, args ...string) `json:"-"`
 	Semaphore       chan struct{}                    `json:"-"` // -p flag controls cap
 	Debug           bool
+	Nobounds        bool
 	PrintSizes      string
 	PrintAllocs     *regexp.Regexp // regexp string
 	PrintStacks     bool

compileopts/options_test.go

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

compileopts/target.go

@@ -178,6 +178,21 @@ func (spec *TargetSpec) resolveInherits() error {
 
 // Load a target specification.
 func LoadTarget(options *Options) (*TargetSpec, error) {
+	if options.Target == "" && options.GOARCH == "wasm" {
+		// Set a specific target if we're building from a known GOOS/GOARCH
+		// combination that is defined in a target JSON file.
+		switch options.GOOS {
+		case "js":
+			options.Target = "wasm"
+		case "wasip1":
+			options.Target = "wasip1"
+		case "wasip2":
+			options.Target = "wasip2"
+		default:
+			return nil, errors.New("GOARCH=wasm but GOOS is not set correctly. Please set GOOS to wasm, wasip1, or wasip2.")
+		}
+	}
+
 	if options.Target == "" {
 		return defaultTarget(options)
 	}
@@ -247,8 +262,6 @@ func defaultTarget(options *Options) (*TargetSpec, error) {
 		GOOS:             options.GOOS,
 		GOARCH:           options.GOARCH,
 		BuildTags:        []string{options.GOOS, options.GOARCH},
-		GC:               "precise",
-		Scheduler:        "tasks",
 		Linker:           "cc",
 		DefaultStackSize: 1024 * 64, // 64kB
 		GDB:              []string{"gdb"},
@@ -356,17 +369,7 @@ func defaultTarget(options *Options) (*TargetSpec, error) {
 			return nil, fmt.Errorf("invalid GOMIPS=%s: must be hardfloat or softfloat", options.GOMIPS)
 		}
 	case "wasm":
-		llvmarch = "wasm32"
-		spec.CPU = "generic"
-		spec.Features = "+bulk-memory,+mutable-globals,+nontrapping-fptoint,+sign-ext,-multivalue,-reference-types"
-		spec.BuildTags = append(spec.BuildTags, "tinygo.wasm")
-		spec.CFlags = append(spec.CFlags,
-			"-mbulk-memory",
-			"-mnontrapping-fptoint",
-			"-mno-multivalue",
-			"-mno-reference-types",
-			"-msign-ext",
-		)
+		return nil, fmt.Errorf("GOARCH=wasm but GOOS is unset. Please set GOOS to wasm, wasip1, or wasip2.")
 	default:
 		return nil, fmt.Errorf("unknown GOARCH=%s", options.GOARCH)
 	}
@@ -376,11 +379,13 @@ func defaultTarget(options *Options) (*TargetSpec, error) {
 	llvmvendor := "unknown"
 	switch options.GOOS {
 	case "darwin":
+		spec.GC = "boehm"
 		platformVersion := "10.12.0"
 		if options.GOARCH == "arm64" {
 			platformVersion = "11.0.0" // first macosx platform with arm64 support
 		}
 		llvmvendor = "apple"
+		spec.Scheduler = "tasks"
 		spec.Linker = "ld.lld"
 		spec.Libc = "darwin-libSystem"
 		// Use macosx* instead of darwin, otherwise darwin/arm64 will refer to
@@ -398,6 +403,8 @@ func defaultTarget(options *Options) (*TargetSpec, error) {
 			"src/runtime/runtime_unix.c",
 			"src/runtime/signal.c")
 	case "linux":
+		spec.GC = "boehm"
+		spec.Scheduler = "threads"
 		spec.Linker = "ld.lld"
 		spec.RTLib = "compiler-rt"
 		spec.Libc = "musl"
@@ -418,9 +425,12 @@ func defaultTarget(options *Options) (*TargetSpec, error) {
 		}
 		spec.ExtraFiles = append(spec.ExtraFiles,
 			"src/internal/futex/futex_linux.c",
+			"src/internal/task/task_threads.c",
 			"src/runtime/runtime_unix.c",
 			"src/runtime/signal.c")
 	case "windows":
+		spec.GC = "boehm"
+		spec.Scheduler = "tasks"
 		spec.Linker = "ld.lld"
 		spec.Libc = "mingw-w64"
 		// Note: using a medium code model, low image base and no ASLR
@@ -446,23 +456,8 @@ func defaultTarget(options *Options) (*TargetSpec, error) {
 			"--no-insert-timestamp",
 			"--no-dynamicbase",
 		)
-	case "wasip1":
-		spec.GC = "" // use default GC
-		spec.Scheduler = "asyncify"
-		spec.Linker = "wasm-ld"
-		spec.RTLib = "compiler-rt"
-		spec.Libc = "wasi-libc"
-		spec.DefaultStackSize = 1024 * 64 // 64kB
-		spec.LDFlags = append(spec.LDFlags,
-			"--stack-first",
-			"--no-demangle",
-		)
-		spec.Emulator = "wasmtime run --dir={tmpDir}::/tmp {}"
-		spec.ExtraFiles = append(spec.ExtraFiles,
-			"src/runtime/asm_tinygowasm.S",
-			"src/internal/task/task_asyncify_wasm.S",
-		)
-		llvmos = "wasi"
+	case "wasm", "wasip1", "wasip2":
+		return nil, fmt.Errorf("GOOS=%s but GOARCH is unset. Please set GOARCH to wasm", options.GOOS)
 	default:
 		return nil, fmt.Errorf("unknown GOOS=%s", options.GOOS)
 	}

compiler/alias.go

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

compiler/compiler.go

@@ -58,6 +58,7 @@ type Config struct {
 	MaxStackAlloc      uint64
 	NeedsStackObjects  bool
 	Debug              bool // Whether to emit debug information in the LLVM module.
+	Nobounds           bool // Whether to skip bounds checks
 	PanicStrategy      string
 }
 

compiler/llvm.go

@@ -371,13 +371,6 @@ func (c *compilerContext) getPointerBitmap(typ llvm.Type, pos token.Pos) *big.In
 		return big.NewInt(1)
 	case llvm.StructTypeKind:
 		ptrs := big.NewInt(0)
-		if typ.StructName() == "runtime.funcValue" {
-			// Hack: the type runtime.funcValue contains an 'id' field which is
-			// of type uintptr, but before the LowerFuncValues pass it actually
-			// contains a pointer (ptrtoint) to a global. This trips up the
-			// interp package. Therefore, make the id field a pointer for now.
-			typ = c.ctx.StructType([]llvm.Type{c.dataPtrType, c.dataPtrType}, false)
-		}
 		for i, subtyp := range typ.StructElementTypes() {
 			subptrs := c.getPointerBitmap(subtyp, pos)
 			if subptrs.BitLen() == 0 {

compiler/symbol.go

@@ -432,13 +432,16 @@ func (c *compilerContext) parsePragmas(info *functionInfo, f *ssa.Function) {
 			// pass for C variadic functions. This includes both explicit
 			// (with ...) and implicit (no parameters in signature)
 			// functions.
-			if strings.HasPrefix(f.Name(), "C.") {
-				// This prefix cannot naturally be created, it must have
-				// been created as a result of CGo preprocessing.
+			if strings.HasPrefix(f.Name(), "_Cgo_") {
+				// This prefix was created as a result of CGo preprocessing.
 				info.variadic = true
 			}
 		}
 	}
+
+	if c.Nobounds {
+		info.nobounds = true
+	}
 }
 
 // Check whether this function can be used in //go:wasmimport or
@@ -447,7 +450,7 @@ func (c *compilerContext) parsePragmas(info *functionInfo, f *ssa.Function) {
 // The list of allowed types is based on this proposal:
 // https://github.com/golang/go/issues/59149
 func (c *compilerContext) checkWasmImportExport(f *ssa.Function, pragma string) {
-	if c.pkg.Path() == "runtime" || c.pkg.Path() == "syscall/js" || c.pkg.Path() == "syscall" {
+	if c.pkg.Path() == "runtime" || c.pkg.Path() == "syscall/js" || c.pkg.Path() == "syscall" || c.pkg.Path() == "crypto/internal/sysrand" {
 		// The runtime is a special case. Allow all kinds of parameters
 		// (importantly, including pointers).
 		return

flake.nix

@@ -21,7 +21,6 @@
 #   make llvm-source            # fetch compiler-rt
 #   git submodule update --init # fetch lots of other libraries and SVD files
 #   make gen-device -j4         # build src/device/*/*.go files
-#   make wasi-libc              # build support for wasi/wasm
 #
 # With this, you should have an environment that can compile anything - except
 # for the Xtensa architecture (ESP8266/ESP32) because support for that lives in
@@ -64,14 +63,6 @@
             #openocd
           ];
           shellHook= ''
-            # Configure CLANG, LLVM_AR, and LLVM_NM for `make wasi-libc`.
-            # Without setting these explicitly, Homebrew versions might be used
-            # or the default `ar` and `nm` tools might be used (which don't
-            # support wasi).
-            export CLANG="clang-18 -resource-dir ${llvmPackages_18.clang.cc.lib}/lib/clang/18"
-            export LLVM_AR=llvm-ar
-            export LLVM_NM=llvm-nm
-
             # Make `make smoketest` work (the default is `md5`, while Nix only
             # has `md5sum`).
             export MD5SUM=md5sum

goenv/version.go

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

internal/wasm-tools/go.mod

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

internal/wasm-tools/go.sum

@@ -1,5 +1,3 @@
-github.com/bytecodealliance/wasm-tools-go v0.3.1 h1:9Q9PjSzkbiVmkUvZ7nYCfJ02mcQDBalxycA3s8g7kR4=
-github.com/bytecodealliance/wasm-tools-go v0.3.1/go.mod h1:vNAQ8DAEp6xvvk+TUHah5DslLEa76f4H6e737OeaxuY=
 github.com/coreos/go-semver v0.3.1 h1:yi21YpKnrx1gt5R+la8n5WgS0kCrsPp33dmEyHReZr4=
 github.com/coreos/go-semver v0.3.1/go.mod h1:irMmmIw/7yzSRPWryHsK7EYSg09caPQL03VsM8rvUec=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -7,16 +5,16 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/docker/libtrust v0.0.0-20160708172513-aabc10ec26b7 h1:UhxFibDNY/bfvqU5CAUmr9zpesgbU6SWc8/B4mflAE4=
 github.com/docker/libtrust v0.0.0-20160708172513-aabc10ec26b7/go.mod h1:cyGadeNEkKy96OOhEzfZl+yxihPEzKnqJwvfuSUqbZE=
-github.com/klauspost/compress v1.17.9 h1:6KIumPrER1LHsvBVuDa0r5xaG0Es51mhhB9BQB2qeMA=
-github.com/klauspost/compress v1.17.9/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw=
-github.com/olareg/olareg v0.1.0 h1:1dXBOgPrig5N7zoXyIZVQqU0QBo6sD9pbL6UYjY75CA=
-github.com/olareg/olareg v0.1.0/go.mod h1:RBuU7JW7SoIIxZKzLRhq8sVtQeAHzCAtRrXEBx2KlM4=
+github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
+github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
+github.com/olareg/olareg v0.1.1 h1:Ui7q93zjcoF+U9U71sgqgZWByDoZOpqHitUXEu2xV+g=
+github.com/olareg/olareg v0.1.1/go.mod h1:w8NP4SWrHHtxsFaUiv1lnCnYPm4sN1seCd2h7FK/dc0=
 github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U=
 github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/regclient/regclient v0.7.1 h1:qEsJrTmZd98fZKjueAbrZCSNGU+ifnr6xjlSAs3WOPs=
-github.com/regclient/regclient v0.7.1/go.mod h1:+w/BFtJuw0h0nzIw/z2+1FuA2/dVXBzDq4rYmziJpMc=
+github.com/regclient/regclient v0.8.2 h1:23BQ3jWgKYHHIXUhp/S9laVJDHDoOQaQCzXMJ4undVE=
+github.com/regclient/regclient v0.8.2/go.mod h1:uGyetv0o6VLyRDjtfeBqp/QBwRLJ3Hcn07/+8QbhNcM=
 github.com/sergi/go-diff v1.3.1 h1:xkr+Oxo4BOQKmkn/B9eMK0g5Kg/983T9DqqPHwYqD+8=
 github.com/sergi/go-diff v1.3.1/go.mod h1:aMJSSKb2lpPvRNec0+w3fl7LP9IOFzdc9Pa4NFbPK1I=
 github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
@@ -25,19 +23,25 @@ github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/tetratelabs/wazero v1.9.0 h1:IcZ56OuxrtaEz8UYNRHBrUa9bYeX9oVY93KspZZBf/I=
+github.com/tetratelabs/wazero v1.9.0/go.mod h1:TSbcXCfFP0L2FGkRPxHphadXPjo1T6W+CseNNY7EkjM=
 github.com/ulikunitz/xz v0.5.12 h1:37Nm15o69RwBkXM0J6A5OlE67RZTfzUxTj8fB3dfcsc=
 github.com/ulikunitz/xz v0.5.12/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
-github.com/urfave/cli/v3 v3.0.0-alpha9.2 h1:CL8llQj3dGRLVQQzHxS+ZYRLanOuhyK1fXgLKD+qV+Y=
-github.com/urfave/cli/v3 v3.0.0-alpha9.2/go.mod h1:FnIeEMYu+ko8zP1F9Ypr3xkZMIDqW3DR92yUtY39q1Y=
-golang.org/x/mod v0.21.0 h1:vvrHzRwRfVKSiLrG+d4FMl/Qi4ukBCE6kZlTUkDYRT0=
-golang.org/x/mod v0.21.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY=
-golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ=
-golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+github.com/urfave/cli/v3 v3.0.0-beta1 h1:6DTaaUarcM0wX7qj5Hcvs+5Dm3dyUTBbEwIWAjcw9Zg=
+github.com/urfave/cli/v3 v3.0.0-beta1/go.mod h1:FnIeEMYu+ko8zP1F9Ypr3xkZMIDqW3DR92yUtY39q1Y=
+go.bytecodealliance.org v0.6.2 h1:Jy4u5DVmSkXgsnwojBhJ+AD/YsJsR3VzVnxF0xRCqTQ=
+go.bytecodealliance.org v0.6.2/go.mod h1:gqjTJm0y9NSksG4py/lSjIQ/SNuIlOQ+hCIEPQwtJgA=
+go.bytecodealliance.org/cm v0.2.2 h1:M9iHS6qs884mbQbIjtLX1OifgyPG9DuMs2iwz8G4WQA=
+go.bytecodealliance.org/cm v0.2.2/go.mod h1:JD5vtVNZv7sBoQQkvBvAAVKJPhR/bqBH7yYXTItMfZI=
+golang.org/x/mod v0.24.0 h1:ZfthKaKaT4NrhGVZHO1/WDTwGES4De8KtWO0SIbNJMU=
+golang.org/x/mod v0.24.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww=
+golang.org/x/sync v0.11.0 h1:GGz8+XQP4FvTTrjZPzNKTMFtSXH80RAzG+5ghFPgK9w=
+golang.org/x/sync v0.11.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.26.0 h1:KHjCJyddX0LoSTb3J+vWpupP9p0oznkqVk/IfjymZbo=
-golang.org/x/sys v0.26.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/tools v0.26.0 h1:v/60pFQmzmT9ExmjDv2gGIfi3OqfKoEP6I5+umXlbnQ=
-golang.org/x/tools v0.26.0/go.mod h1:TPVVj70c7JJ3WCazhD8OdXcZg/og+b9+tH/KxylGwH0=
+golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik=
+golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/tools v0.30.0 h1:BgcpHewrV5AUp2G9MebG4XPFI1E2W41zU1SaqVA9vJY=
+golang.org/x/tools v0.30.0/go.mod h1:c347cR/OJfw5TI+GfX7RUPNMdDRRbjvYTS0jPyvsVtY=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

internal/wasm-tools/tools.go

@@ -5,7 +5,8 @@
 package tools
 
 import (
-	_ "github.com/bytecodealliance/wasm-tools-go/cmd/wit-bindgen-go"
+	_ "go.bytecodealliance.org/cm"
+	_ "go.bytecodealliance.org/cmd/wit-bindgen-go"
 )
 
-//go:generate go install github.com/bytecodealliance/wasm-tools-go/cmd/wit-bindgen-go
+//go:generate go install go.bytecodealliance.org/cmd/wit-bindgen-go

interp/memory.go

@@ -824,19 +824,6 @@ func (v rawValue) rawLLVMValue(mem *memoryView) (llvm.Value, error) {
 			if err != nil {
 				return llvm.Value{}, err
 			}
-			if !field.IsAGlobalVariable().IsNil() {
-				elementType := field.GlobalValueType()
-				if elementType.TypeKind() == llvm.StructTypeKind {
-					// There are some special pointer types that should be used
-					// as a ptrtoint, so that they can be used in certain
-					// optimizations.
-					name := elementType.StructName()
-					if name == "runtime.funcValueWithSignature" {
-						uintptrType := ctx.IntType(int(mem.r.pointerSize) * 8)
-						field = llvm.ConstPtrToInt(field, uintptrType)
-					}
-				}
-			}
 			structFields = append(structFields, field)
 			i += mem.r.pointerSize
 			continue

loader/goroot.go

@@ -269,6 +269,8 @@ func pathsToOverride(goMinor int, needsSyscallPackage bool) map[string]bool {
 
 	if needsSyscallPackage {
 		paths["syscall/"] = true // include syscall/js
+		paths["internal/syscall/"] = true
+		paths["internal/syscall/unix/"] = false
 	}
 	return paths
 }

main.go

@@ -1492,7 +1492,7 @@ func main() {
 	command := os.Args[1]
 
 	opt := flag.String("opt", "z", "optimization level: 0, 1, 2, s, z")
-	gc := flag.String("gc", "", "garbage collector to use (none, leaking, conservative)")
+	gc := flag.String("gc", "", "garbage collector to use (none, leaking, conservative, custom, precise, boehm)")
 	panicStrategy := flag.String("panic", "print", "panic strategy (print, trap)")
 	scheduler := flag.String("scheduler", "", "which scheduler to use (none, tasks, asyncify)")
 	serial := flag.String("serial", "", "which serial output to use (none, uart, usb, rtt)")
@@ -1514,6 +1514,7 @@ func main() {
 	printCommands := flag.Bool("x", false, "Print commands")
 	parallelism := flag.Int("p", runtime.GOMAXPROCS(0), "the number of build jobs that can run in parallel")
 	nodebug := flag.Bool("no-debug", false, "strip debug information")
+	nobounds := flag.Bool("nobounds", false, "do not emit bounds checks")
 	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)")
@@ -1625,6 +1626,7 @@ func main() {
 		SkipDWARF:       *skipDwarf,
 		Semaphore:       make(chan struct{}, *parallelism),
 		Debug:           !*nodebug,
+		Nobounds:        *nobounds,
 		PrintSizes:      *printSize,
 		PrintStacks:     *printStacks,
 		PrintAllocs:     printAllocs,
@@ -1684,8 +1686,9 @@ func main() {
 			usage(command)
 			os.Exit(1)
 		}
-		if options.Target == "" && filepath.Ext(outpath) == ".wasm" {
-			options.Target = "wasm"
+		if filepath.Ext(outpath) == ".wasm" && options.GOARCH != "wasm" && options.Target == "" {
+			fmt.Fprintln(os.Stderr, "you appear to want to build a wasm file, but have not specified either a target flag, or the GOARCH/GOOS to use.")
+			os.Exit(1)
 		}
 
 		err := Build(pkgName, outpath, options)
@@ -1840,10 +1843,7 @@ func main() {
 			os.Exit(1)
 		}
 		config.GoMinorVersion = 0 // this avoids creating the list of Go1.x build tags.
-		if err != nil {
-			fmt.Fprintln(os.Stderr, err)
-			os.Exit(1)
-		}
+
 		cachedGOROOT, err := loader.GetCachedGoroot(config)
 		if err != nil {
 			fmt.Fprintln(os.Stderr, err)

src/crypto/rand/rand_baremetal.go

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

src/device/arm/arm.go

@@ -146,6 +146,11 @@ const (
 	SYST_CALIB_NOREF     = 0x80000000 // Bit NOREF.
 )
 
+// ClearPendingIRQ clears the pending status of the interrupt.
+func ClearPendingIRQ(irq uint32) {
+	NVIC.ICPR[irq>>5].Set(1 << (irq & 0x1F))
+}
+
 // Enable the given interrupt number.
 func EnableIRQ(irq uint32) {
 	NVIC.ISER[irq>>5].Set(1 << (irq & 0x1F))

src/device/riscv/csr.go

@@ -275,3 +275,61 @@ const (
 	DPC      CSR = 0x7B1 // Debug PC.
 	DSCRATCH CSR = 0x7B2 // Debug scratch register.
 )
+
+// Bitfields for the CSR registers above.
+const (
+	// MSTATUS (common bits between RV32 and RV64)
+	MSTATUS_SIE  = 1 << 1
+	MSTATUS_MIE  = 1 << 3
+	MSTATUS_SPIE = 1 << 5
+	MSTATUS_UBE  = 1 << 6
+	MSTATUS_MPIE = 1 << 7
+	MSTATUS_SPP  = 1 << 8
+	MSTATUS_MPRV = 1 << 17
+	MSTATUS_SUM  = 1 << 18
+	MSTATUS_MXR  = 1 << 19
+	MSTATUS_TVM  = 1 << 20
+	MSTATUS_TW   = 1 << 21
+	MSTATUS_TSR  = 1 << 22
+
+	MIE_SSIE = 1 << 1
+	MIE_MSIE = 1 << 3
+	MIE_STIE = 1 << 5
+	MIE_MTIE = 1 << 7
+	MIE_SEIE = 1 << 9
+	MIE_MEIE = 1 << 11
+
+	MIP_SSIP = 1 << 1
+	MIP_MSIP = 1 << 3
+	MIP_STIP = 1 << 5
+	MIP_MTIP = 1 << 7
+	MIP_SEIP = 1 << 9
+	MIP_MEIP = 1 << 11
+)
+
+// Interrupt constants
+const (
+	// MCAUSE values with the topmost bit (interrupt bit) set.
+	SupervisorSoftwareInterrupt = 1
+	MachineSoftwareInterrupt    = 3
+	SupervisorTimerInterrupt    = 5
+	MachineTimerInterrupt       = 7
+	SupervisorExternalInterrupt = 9
+	MachineExternalInterrupt    = 11
+
+	// MCAUSE values with the topmost bit (interrupt bit) clear.
+	InstructionAddressMisaligned = 0
+	InstructionAccessFault       = 1
+	IllegalInstruction           = 2
+	Breakpoint                   = 3
+	LoadAddressMisaligned        = 4
+	LoadAccessFault              = 5
+	StoreOrAMOAddressMisaligned  = 6
+	StoreOrAMOAccessFault        = 7
+	EnvironmentCallFromUMode     = 8
+	EnvironmentCallFromSMode     = 9
+	EnvironmentCallFromMMode     = 11
+	InstructionPageFault         = 12
+	LoadPageFault                = 13
+	StoreOrAMOPageFault          = 15
+)

src/examples/bench-goro/bench.go

@@ -0,0 +1,40 @@
+package main
+
+import (
+	"machine"
+	"runtime"
+	"sync"
+	"time"
+)
+
+const N = 500000
+const Ngoro = 4
+
+func main() {
+	start := time.Now()
+	var wg sync.WaitGroup
+	wg.Add(Ngoro)
+	for i := 0; i < Ngoro; i++ {
+		go adder(&wg, N)
+	}
+	wg.Wait()
+	elapsed := time.Since(start)
+	goroutineCtxSwitchOverhead := (elapsed / (Ngoro * N)).String()
+
+	elapsedstr := elapsed.String()
+	machine.LED.Configure(machine.PinConfig{Mode: machine.PinOutput})
+	for {
+		println("bench:", elapsedstr, "goroutine ctx switch:", goroutineCtxSwitchOverhead)
+		machine.LED.High()
+		time.Sleep(elapsed)
+		machine.LED.Low()
+		time.Sleep(elapsed)
+	}
+}
+
+func adder(wg *sync.WaitGroup, num int) {
+	for i := 0; i < num; i++ {
+		runtime.Gosched()
+	}
+	wg.Done()
+}

src/internal/abi/type.go

@@ -0,0 +1,7 @@
+package abi
+
+type Type struct {
+	// Intentionally left empty. TinyGo uses a different way to represent types,
+	// so this is unimplementable. The type definition here is purely for
+	// compatibility.
+}

src/internal/cm/case.go

@@ -0,0 +1,51 @@
+package cm
+
+// CaseUnmarshaler returns an function that can unmarshal text into
+// [variant] or [enum] case T.
+//
+// [enum]: https://component-model.bytecodealliance.org/design/wit.html#enums
+// [variant]: https://component-model.bytecodealliance.org/design/wit.html#variants
+func CaseUnmarshaler[T ~uint8 | ~uint16 | ~uint32](cases []string) func(v *T, text []byte) error {
+	if len(cases) <= linearScanThreshold {
+		return func(v *T, text []byte) error {
+			if len(text) == 0 {
+				return &emptyTextError{}
+			}
+			s := string(text)
+			for i := 0; i < len(cases); i++ {
+				if cases[i] == s {
+					*v = T(i)
+					return nil
+				}
+			}
+			return &noMatchingCaseError{}
+		}
+	}
+
+	m := make(map[string]T, len(cases))
+	for i, v := range cases {
+		m[v] = T(i)
+	}
+
+	return func(v *T, text []byte) error {
+		if len(text) == 0 {
+			return &emptyTextError{}
+		}
+		c, ok := m[string(text)]
+		if !ok {
+			return &noMatchingCaseError{}
+		}
+		*v = c
+		return nil
+	}
+}
+
+const linearScanThreshold = 16
+
+type emptyTextError struct{}
+
+func (*emptyTextError) Error() string { return "empty text" }
+
+type noMatchingCaseError struct{}
+
+func (*noMatchingCaseError) Error() string { return "no matching case" }

src/internal/cm/docs.go

@@ -1,4 +1,4 @@
-// Package cm contains types and functions for interfacing with the WebAssembly Component Model.
+// Package cm provides types and functions for interfacing with the WebAssembly Component Model.
 //
 // The types in this package (such as [List], [Option], [Result], and [Variant]) are designed to match the memory layout
 // of [Component Model] types as specified in the [Canonical ABI].

src/internal/cm/empty.s

@@ -0,0 +1,3 @@
+// This file exists for testing this package without WebAssembly,
+// allowing empty function bodies with a //go:wasmimport directive.
+// See https://pkg.go.dev/cmd/compile for more information.

src/internal/cm/error.go

@@ -0,0 +1,40 @@
+package cm
+
+import "unsafe"
+
+// ErrorContext represents the Component Model [error-context] type,
+// an immutable, non-deterministic, host-defined value meant to aid in debugging.
+//
+// [error-context]: https://github.com/WebAssembly/component-model/blob/main/design/mvp/Explainer.md#error-context-type
+type ErrorContext struct {
+	_ HostLayout
+	errorContext
+}
+
+type errorContext uint32
+
+// Error implements the [error] interface. It returns the debug message associated with err.
+func (err errorContext) Error() string {
+	return err.DebugMessage()
+}
+
+// String implements [fmt.Stringer].
+func (err errorContext) String() string {
+	return err.DebugMessage()
+}
+
+// DebugMessage represents the Canonical ABI [error-context.debug-message] function.
+//
+// [error-context.debug-message]: https://github.com/WebAssembly/component-model/blob/main/design/mvp/Explainer.md#error-contextdebug-message
+func (err errorContext) DebugMessage() string {
+	var s string
+	wasmimport_errorContextDebugMessage(err, unsafe.Pointer(&s))
+	return s
+}
+
+// Drop represents the Canonical ABI [error-context.drop] function.
+//
+// [error-context.drop]: https://github.com/WebAssembly/component-model/blob/main/design/mvp/Explainer.md#error-contextdrop
+func (err errorContext) Drop() {
+	wasmimport_errorContextDrop(err)
+}

src/internal/cm/error.wasm.go

@@ -0,0 +1,13 @@
+package cm
+
+import "unsafe"
+
+// msg uses unsafe.Pointer for compatibility with go1.23 and lower.
+//
+//go:wasmimport canon error-context.debug-message
+//go:noescape
+func wasmimport_errorContextDebugMessage(err errorContext, msg unsafe.Pointer)
+
+//go:wasmimport canon error-context.drop
+//go:noescape
+func wasmimport_errorContextDrop(err errorContext)

src/internal/cm/future.go

@@ -0,0 +1,15 @@
+package cm
+
+// Future represents the Component Model [future] type.
+// A future is a special case of stream. In non-error cases,
+// a future delivers exactly one value before being automatically closed.
+//
+// [future]: https://github.com/WebAssembly/component-model/blob/main/design/mvp/Explainer.md#asynchronous-value-types
+type Future[T any] struct {
+	_ HostLayout
+	future[T]
+}
+
+type future[T any] uint32
+
+// TODO: implement methods on type future

src/internal/cm/list.go

@@ -1,6 +1,8 @@
 package cm
 
-import "unsafe"
+import (
+	"unsafe"
+)
 
 // List represents a Component Model list.
 // The binary representation of list<T> is similar to a Go slice minus the cap field.

src/internal/cm/stream.go

@@ -0,0 +1,15 @@
+package cm
+
+// Stream represents the Component Model [stream] type.
+// A stream is a special case of stream. In non-error cases,
+// a stream delivers exactly one value before being automatically closed.
+//
+// [stream]: https://github.com/WebAssembly/component-model/blob/main/design/mvp/Explainer.md#asynchronous-value-types
+type Stream[T any] struct {
+	_ HostLayout
+	stream[T]
+}
+
+type stream[T any] uint32
+
+// TODO: implement methods on type stream

src/internal/cm/variant.go

@@ -3,10 +3,9 @@ package cm
 import "unsafe"
 
 // Discriminant is the set of types that can represent the tag or discriminator of a variant.
-// Use bool for 2-case variant types, result<T>, or option<T> types, uint8 where there are 256 or
-// fewer cases, uint16 for up to 65,536 cases, or uint32 for anything greater.
+// Use uint8 where there are 256 or fewer cases, uint16 for up to 65,536 cases, or uint32 for anything greater.
 type Discriminant interface {
-	bool | uint8 | uint16 | uint32
+	uint8 | uint16 | uint32
 }
 
 // Variant represents a loosely-typed Component Model variant.

src/internal/reflectlite/deepequal.go

@@ -0,0 +1,196 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Deep equality test via reflection
+
+package reflectlite
+
+import "unsafe"
+
+// During deepValueEqual, must keep track of checks that are
+// in progress. The comparison algorithm assumes that all
+// checks in progress are true when it reencounters them.
+// Visited comparisons are stored in a map indexed by visit.
+type visit struct {
+	a1  unsafe.Pointer
+	a2  unsafe.Pointer
+	typ *RawType
+}
+
+// Tests for deep equality using reflected types. The map argument tracks
+// comparisons that have already been seen, which allows short circuiting on
+// recursive types.
+func deepValueEqual(v1, v2 Value, visited map[visit]struct{}) bool {
+	if !v1.IsValid() || !v2.IsValid() {
+		return v1.IsValid() == v2.IsValid()
+	}
+	if v1.typecode != v2.typecode {
+		return false
+	}
+
+	// We want to avoid putting more in the visited map than we need to.
+	// For any possible reference cycle that might be encountered,
+	// hard(v1, v2) needs to return true for at least one of the types in the cycle,
+	// and it's safe and valid to get Value's internal pointer.
+	hard := func(v1, v2 Value) bool {
+		switch v1.Kind() {
+		case Map, Slice, Ptr, Interface:
+			// Nil pointers cannot be cyclic. Avoid putting them in the visited map.
+			return !v1.IsNil() && !v2.IsNil()
+		}
+		return false
+	}
+
+	if hard(v1, v2) {
+		addr1 := v1.pointer()
+		addr2 := v2.pointer()
+		if uintptr(addr1) > uintptr(addr2) {
+			// Canonicalize order to reduce number of entries in visited.
+			// Assumes non-moving garbage collector.
+			addr1, addr2 = addr2, addr1
+		}
+
+		// Short circuit if references are already seen.
+		v := visit{addr1, addr2, v1.typecode}
+		if _, ok := visited[v]; ok {
+			return true
+		}
+
+		// Remember for later.
+		visited[v] = struct{}{}
+	}
+
+	switch v1.Kind() {
+	case Array:
+		for i := 0; i < v1.Len(); i++ {
+			if !deepValueEqual(v1.Index(i), v2.Index(i), visited) {
+				return false
+			}
+		}
+		return true
+	case Slice:
+		if v1.IsNil() != v2.IsNil() {
+			return false
+		}
+		if v1.Len() != v2.Len() {
+			return false
+		}
+		if v1.UnsafePointer() == v2.UnsafePointer() {
+			return true
+		}
+		for i := 0; i < v1.Len(); i++ {
+			if !deepValueEqual(v1.Index(i), v2.Index(i), visited) {
+				return false
+			}
+		}
+		return true
+	case Interface:
+		if v1.IsNil() || v2.IsNil() {
+			return v1.IsNil() == v2.IsNil()
+		}
+		return deepValueEqual(v1.Elem(), v2.Elem(), visited)
+	case Ptr:
+		if v1.UnsafePointer() == v2.UnsafePointer() {
+			return true
+		}
+		return deepValueEqual(v1.Elem(), v2.Elem(), visited)
+	case Struct:
+		for i, n := 0, v1.NumField(); i < n; i++ {
+			if !deepValueEqual(v1.Field(i), v2.Field(i), visited) {
+				return false
+			}
+		}
+		return true
+	case Map:
+		if v1.IsNil() != v2.IsNil() {
+			return false
+		}
+		if v1.Len() != v2.Len() {
+			return false
+		}
+		if v1.UnsafePointer() == v2.UnsafePointer() {
+			return true
+		}
+		for _, k := range v1.MapKeys() {
+			val1 := v1.MapIndex(k)
+			val2 := v2.MapIndex(k)
+			if !val1.IsValid() || !val2.IsValid() || !deepValueEqual(val1, val2, visited) {
+				return false
+			}
+		}
+		return true
+	case Func:
+		if v1.IsNil() && v2.IsNil() {
+			return true
+		}
+		// Can't do better than this:
+		return false
+	default:
+		// Normal equality suffices
+		return valueInterfaceUnsafe(v1) == valueInterfaceUnsafe(v2)
+	}
+}
+
+// DeepEqual reports whether x and y are “deeply equal”, defined as follows.
+// Two values of identical type are deeply equal if one of the following cases applies.
+// Values of distinct types are never deeply equal.
+//
+// Array values are deeply equal when their corresponding elements are deeply equal.
+//
+// Struct values are deeply equal if their corresponding fields,
+// both exported and unexported, are deeply equal.
+//
+// Func values are deeply equal if both are nil; otherwise they are not deeply equal.
+//
+// Interface values are deeply equal if they hold deeply equal concrete values.
+//
+// Map values are deeply equal when all of the following are true:
+// they are both nil or both non-nil, they have the same length,
+// and either they are the same map object or their corresponding keys
+// (matched using Go equality) map to deeply equal values.
+//
+// Pointer values are deeply equal if they are equal using Go's == operator
+// or if they point to deeply equal values.
+//
+// Slice values are deeply equal when all of the following are true:
+// they are both nil or both non-nil, they have the same length,
+// and either they point to the same initial entry of the same underlying array
+// (that is, &x[0] == &y[0]) or their corresponding elements (up to length) are deeply equal.
+// Note that a non-nil empty slice and a nil slice (for example, []byte{} and []byte(nil))
+// are not deeply equal.
+//
+// Other values - numbers, bools, strings, and channels - are deeply equal
+// if they are equal using Go's == operator.
+//
+// In general DeepEqual is a recursive relaxation of Go's == operator.
+// However, this idea is impossible to implement without some inconsistency.
+// Specifically, it is possible for a value to be unequal to itself,
+// either because it is of func type (uncomparable in general)
+// or because it is a floating-point NaN value (not equal to itself in floating-point comparison),
+// or because it is an array, struct, or interface containing
+// such a value.
+// On the other hand, pointer values are always equal to themselves,
+// even if they point at or contain such problematic values,
+// because they compare equal using Go's == operator, and that
+// is a sufficient condition to be deeply equal, regardless of content.
+// DeepEqual has been defined so that the same short-cut applies
+// to slices and maps: if x and y are the same slice or the same map,
+// they are deeply equal regardless of content.
+//
+// As DeepEqual traverses the data values it may find a cycle. The
+// second and subsequent times that DeepEqual compares two pointer
+// values that have been compared before, it treats the values as
+// equal rather than examining the values to which they point.
+// This ensures that DeepEqual terminates.
+func DeepEqual(x, y interface{}) bool {
+	if x == nil || y == nil {
+		return x == y
+	}
+	v1 := ValueOf(x)
+	v2 := ValueOf(y)
+	if v1.typecode != v2.typecode {
+		return false
+	}
+	return deepValueEqual(v1, v2, make(map[visit]struct{}))
+}

src/internal/reflectlite/endian_big.go

@@ -1,6 +1,6 @@
 //go:build mips
 
-package reflect
+package reflectlite
 
 import "unsafe"
 

src/internal/reflectlite/endian_little.go

@@ -1,6 +1,6 @@
 //go:build !mips
 
-package reflect
+package reflectlite
 
 import "unsafe"
 

src/internal/reflectlite/reflect.go

@@ -1,51 +0,0 @@
-package reflectlite
-
-import "reflect"
-
-func Swapper(slice interface{}) func(i, j int) {
-	return reflect.Swapper(slice)
-}
-
-type Kind = reflect.Kind
-type Type = reflect.Type
-type Value = reflect.Value
-
-const (
-	Invalid       Kind = reflect.Invalid
-	Bool          Kind = reflect.Bool
-	Int           Kind = reflect.Int
-	Int8          Kind = reflect.Int8
-	Int16         Kind = reflect.Int16
-	Int32         Kind = reflect.Int32
-	Int64         Kind = reflect.Int64
-	Uint          Kind = reflect.Uint
-	Uint8         Kind = reflect.Uint8
-	Uint16        Kind = reflect.Uint16
-	Uint32        Kind = reflect.Uint32
-	Uint64        Kind = reflect.Uint64
-	Uintptr       Kind = reflect.Uintptr
-	Float32       Kind = reflect.Float32
-	Float64       Kind = reflect.Float64
-	Complex64     Kind = reflect.Complex64
-	Complex128    Kind = reflect.Complex128
-	Array         Kind = reflect.Array
-	Chan          Kind = reflect.Chan
-	Func          Kind = reflect.Func
-	Interface     Kind = reflect.Interface
-	Map           Kind = reflect.Map
-	Ptr           Kind = reflect.Ptr
-	Slice         Kind = reflect.Slice
-	String        Kind = reflect.String
-	Struct        Kind = reflect.Struct
-	UnsafePointer Kind = reflect.UnsafePointer
-)
-
-func ValueOf(i interface{}) reflect.Value {
-	return reflect.ValueOf(i)
-}
-
-func TypeOf(i interface{}) reflect.Type {
-	return reflect.TypeOf(i)
-}
-
-type ValueError = reflect.ValueError

src/internal/reflectlite/strconv.go

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package reflect
+package reflectlite
 
 import (
 	"unicode/utf8"

src/internal/reflectlite/swapper.go

@@ -0,0 +1,40 @@
+package reflectlite
+
+import "unsafe"
+
+// Some of code here has been copied from the Go sources:
+//   https://github.com/golang/go/blob/go1.15.2/src/reflect/swapper.go
+// It has the following copyright note:
+//
+// 		Copyright 2016 The Go Authors. All rights reserved.
+// 		Use of this source code is governed by a BSD-style
+// 		license that can be found in the LICENSE file.
+
+func Swapper(slice interface{}) func(i, j int) {
+	v := ValueOf(slice)
+	if v.Kind() != Slice {
+		panic(&ValueError{Method: "Swapper"})
+	}
+
+	// Just return Nop func if nothing to swap.
+	if v.Len() < 2 {
+		return func(i, j int) {}
+	}
+
+	typ := v.typecode.Elem()
+	size := typ.Size()
+
+	header := (*sliceHeader)(v.value)
+	tmp := unsafe.Pointer(&make([]byte, size)[0])
+
+	return func(i, j int) {
+		if uint(i) >= uint(header.len) || uint(j) >= uint(header.len) {
+			panic("reflect: slice index out of range")
+		}
+		val1 := unsafe.Add(header.data, uintptr(i)*size)
+		val2 := unsafe.Add(header.data, uintptr(j)*size)
+		memcpy(tmp, val1, size)
+		memcpy(val1, val2, size)
+		memcpy(val2, tmp, size)
+	}
+}

src/internal/reflectlite/visiblefields.go

@@ -0,0 +1,105 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package reflectlite
+
+// VisibleFields returns all the visible fields in t, which must be a
+// struct type. A field is defined as visible if it's accessible
+// directly with a FieldByName call. The returned fields include fields
+// inside anonymous struct members and unexported fields. They follow
+// the same order found in the struct, with anonymous fields followed
+// immediately by their promoted fields.
+//
+// For each element e of the returned slice, the corresponding field
+// can be retrieved from a value v of type t by calling v.FieldByIndex(e.Index).
+func VisibleFields(t Type) []StructField {
+	if t == nil {
+		panic("reflect: VisibleFields(nil)")
+	}
+	if t.Kind() != Struct {
+		panic("reflect.VisibleFields of non-struct type")
+	}
+	w := &visibleFieldsWalker{
+		byName:   make(map[string]int),
+		visiting: make(map[Type]bool),
+		fields:   make([]StructField, 0, t.NumField()),
+		index:    make([]int, 0, 2),
+	}
+	w.walk(t)
+	// Remove all the fields that have been hidden.
+	// Use an in-place removal that avoids copying in
+	// the common case that there are no hidden fields.
+	j := 0
+	for i := range w.fields {
+		f := &w.fields[i]
+		if f.Name == "" {
+			continue
+		}
+		if i != j {
+			// A field has been removed. We need to shuffle
+			// all the subsequent elements up.
+			w.fields[j] = *f
+		}
+		j++
+	}
+	return w.fields[:j]
+}
+
+type visibleFieldsWalker struct {
+	byName   map[string]int
+	visiting map[Type]bool
+	fields   []StructField
+	index    []int
+}
+
+// walk walks all the fields in the struct type t, visiting
+// fields in index preorder and appending them to w.fields
+// (this maintains the required ordering).
+// Fields that have been overridden have their
+// Name field cleared.
+func (w *visibleFieldsWalker) walk(t Type) {
+	if w.visiting[t] {
+		return
+	}
+	w.visiting[t] = true
+	for i := 0; i < t.NumField(); i++ {
+		f := t.Field(i)
+		w.index = append(w.index, i)
+		add := true
+		if oldIndex, ok := w.byName[f.Name]; ok {
+			old := &w.fields[oldIndex]
+			if len(w.index) == len(old.Index) {
+				// Fields with the same name at the same depth
+				// cancel one another out. Set the field name
+				// to empty to signify that has happened, and
+				// there's no need to add this field.
+				old.Name = ""
+				add = false
+			} else if len(w.index) < len(old.Index) {
+				// The old field loses because it's deeper than the new one.
+				old.Name = ""
+			} else {
+				// The old field wins because it's shallower than the new one.
+				add = false
+			}
+		}
+		if add {
+			// Copy the index so that it's not overwritten
+			// by the other appends.
+			f.Index = append([]int(nil), w.index...)
+			w.byName[f.Name] = len(w.fields)
+			w.fields = append(w.fields, f)
+		}
+		if f.Anonymous {
+			if f.Type.Kind() == Pointer {
+				f.Type = f.Type.Elem()
+			}
+			if f.Type.Kind() == Struct {
+				w.walk(f.Type)
+			}
+		}
+		w.index = w.index[:len(w.index)-1]
+	}
+	delete(w.visiting, t)
+}

src/internal/syscall/unix/constants.go

@@ -0,0 +1,7 @@
+package unix
+
+const (
+	R_OK = 0x4
+	W_OK = 0x2
+	X_OK = 0x1
+)

src/internal/syscall/unix/eaccess.go

@@ -0,0 +1,10 @@
+package unix
+
+import "syscall"
+
+func Eaccess(path string, mode uint32) error {
+	// We don't support this syscall on baremetal or wasm.
+	// Callers are generally able to deal with this since unix.Eaccess also
+	// isn't available on Android.
+	return syscall.ENOSYS
+}

src/internal/syscall/unix/getrandom.go

@@ -0,0 +1,12 @@
+package unix
+
+type GetRandomFlag uintptr
+
+const (
+	GRND_NONBLOCK GetRandomFlag = 0x0001
+	GRND_RANDOM   GetRandomFlag = 0x0002
+)
+
+func GetRandom(p []byte, flags GetRandomFlag) (n int, err error) {
+	panic("todo: unix.GetRandom")
+}

src/internal/task/atomic-cooperative.go

@@ -1,3 +1,5 @@
+//go:build !scheduler.threads
+
 package task
 
 // Atomics implementation for cooperative systems. The atomic types here aren't

src/internal/task/atomic-preemptive.go

@@ -0,0 +1,14 @@
+//go:build scheduler.threads
+
+package task
+
+// Atomics implementation for non-cooperative systems (multithreaded, etc).
+// These atomic types use real atomic instructions.
+
+import "sync/atomic"
+
+type (
+	Uintptr = atomic.Uintptr
+	Uint32  = atomic.Uint32
+	Uint64  = atomic.Uint64
+)

src/internal/task/futex-cooperative.go

@@ -1,3 +1,5 @@
+//go:build !scheduler.threads
+
 package task
 
 // A futex is a way for userspace to wait with the pointer as the key, and for

src/internal/task/futex-preemptive.go

@@ -0,0 +1,7 @@
+//go:build scheduler.threads
+
+package task
+
+import "internal/futex"
+
+type Futex = futex.Futex

src/internal/task/linux.go

@@ -0,0 +1,9 @@
+//go:build linux && !baremetal
+
+package task
+
+import "unsafe"
+
+// Musl uses a pointer (or unsigned long for C++) so unsafe.Pointer should be
+// fine.
+type threadID unsafe.Pointer

src/internal/task/mutex-cooperative.go

@@ -1,3 +1,5 @@
+//go:build !scheduler.threads
+
 package task
 
 type Mutex struct {

src/internal/task/mutex-preemptive.go

@@ -0,0 +1,71 @@
+//go:build scheduler.threads
+
+package task
+
+// Futex-based mutex.
+// This is largely based on the paper "Futexes are Tricky" by Ulrich Drepper.
+// It describes a few ways to implement mutexes using a futex, and how some
+// seemingly-obvious implementations don't exactly work as intended.
+// Unfortunately, Go atomic operations work slightly differently so we can't
+// copy the algorithm verbatim.
+//
+// The implementation works like this. The futex can have 3 different values,
+// depending on the state:
+//
+//   - 0: the futex is currently unlocked.
+//   - 1: the futex is locked, but is uncontended. There is one special case: if
+//     a contended futex is unlocked, it is set to 0. It is possible for another
+//     thread to lock the futex before the next waiter is woken. But because a
+//     waiter will be woken (if there is one), it will always change to 2
+//     regardless. So this is not a problem.
+//   - 2: the futex is locked, and is contended. At least one thread is trying
+//     to obtain the lock (and is in the contended loop, see below).
+//
+// For the paper, see:
+// https://dept-info.labri.fr/~denis/Enseignement/2008-IR/Articles/01-futex.pdf)
+
+type Mutex struct {
+	futex Futex
+}
+
+func (m *Mutex) Lock() {
+	// Fast path: try to take an uncontended lock.
+	if m.futex.CompareAndSwap(0, 1) {
+		// We obtained the mutex.
+		return
+	}
+
+	// The futex is contended, so we enter the contended loop.
+	// If we manage to change the futex from 0 to 2, we managed to take the
+	// lock. Else, we have to wait until a call to Unlock unlocks this mutex.
+	// (Unlock will wake one waiter when it finds the futex is set to 2 when
+	// unlocking).
+	for m.futex.Swap(2) != 0 {
+		// Wait until we get resumed in Unlock.
+		m.futex.Wait(2)
+	}
+}
+
+func (m *Mutex) Unlock() {
+	if old := m.futex.Swap(0); old == 0 {
+		// Mutex wasn't locked before.
+		panic("sync: unlock of unlocked Mutex")
+	} else if old == 2 {
+		// Mutex was a contended lock, so we need to wake the next waiter.
+		m.futex.Wake()
+	}
+}
+
+// TryLock tries to lock m and reports whether it succeeded.
+//
+// Note that while correct uses of TryLock do exist, they are rare,
+// and use of TryLock is often a sign of a deeper problem
+// in a particular use of mutexes.
+func (m *Mutex) TryLock() bool {
+	// Fast path: try to take an uncontended lock.
+	if m.futex.CompareAndSwap(0, 1) {
+		// We obtained the mutex.
+		return true
+	}
+	return false
+}

src/internal/task/pmutex-cooperative.go

@@ -1,3 +1,5 @@
+//go:build !scheduler.threads
+
 package task
 
 // PMutex is a real mutex on systems that can be either preemptive or threaded,

src/internal/task/pmutex-preemptive.go

@@ -0,0 +1,11 @@
+//go:build scheduler.threads
+
+package task
+
+// PMutex is a real mutex on systems that can be either preemptive or threaded,
+// and a dummy lock on other (purely cooperative) systems.
+//
+// It is mainly useful for short operations that need a lock when threading may
+// be involved, but which do not need a lock with a purely cooperative
+// scheduler.
+type PMutex = Mutex

src/internal/task/semaphore.go

@@ -0,0 +1,32 @@
+package task
+
+// Barebones semaphore implementation.
+// The main limitation is that if there are multiple waiters, a single Post()
+// call won't do anything. Only when Post() has been called to awaken all
+// waiters will the waiters proceed.
+// This limitation is not a problem when there will only be a single waiter.
+type Semaphore struct {
+	futex Futex
+}
+
+// Post (unlock) the semaphore, incrementing the value in the semaphore.
+func (s *Semaphore) Post() {
+	newValue := s.futex.Add(1)
+	if newValue == 0 {
+		s.futex.WakeAll()
+	}
+}
+
+// Wait (lock) the semaphore, decrementing the value in the semaphore.
+func (s *Semaphore) Wait() {
+	delta := int32(-1)
+	value := s.futex.Add(uint32(delta))
+	for {
+		if int32(value) >= 0 {
+			// Semaphore unlocked!
+			return
+		}
+		s.futex.Wait(value)
+		value = s.futex.Load()
+	}
+}

src/internal/task/task.go

@@ -21,6 +21,9 @@ type Task struct {
 	// state is the underlying running state of the task.
 	state state
 
+	// This is needed for some crypto packages.
+	FipsIndicator uint8
+
 	// DeferFrame stores a pointer to the (stack allocated) defer frame of the
 	// goroutine that is used for the recover builtin.
 	DeferFrame unsafe.Pointer

src/internal/task/task_stack.go

@@ -54,8 +54,9 @@ func Pause() {
 	currentTask.state.pause()
 }
 
-//export tinygo_pause
-func pause() {
+//export tinygo_task_exit
+func taskExit() {
+	// TODO: explicitly free the stack after switching back to the scheduler.
 	Pause()
 }
 

src/internal/task/task_stack_386.S

@@ -24,7 +24,7 @@ tinygo_startTask:
     addl $4, %esp
 
     // After return, exit this goroutine. This is a tail call.
-    jmp tinygo_pause
+    jmp tinygo_task_exit
     .cfi_endproc
 
 .global tinygo_swapTask

src/internal/task/task_stack_amd64.S

@@ -30,9 +30,9 @@ tinygo_startTask:
 
     // After return, exit this goroutine. This is a tail call.
     #ifdef __MACH__
-    jmp _tinygo_pause
+    jmp _tinygo_task_exit
     #else
-    jmp tinygo_pause
+    jmp tinygo_task_exit
     #endif
     .cfi_endproc
 

src/internal/task/task_stack_amd64_windows.S

@@ -22,7 +22,7 @@ tinygo_startTask:
 
     // After return, exit this goroutine.
     // This has to be a call, not a jump, to keep the stack correctly aligned.
-    callq tinygo_pause
+    callq tinygo_task_exit
 
 .global tinygo_swapTask
 .section .text.tinygo_swapTask,"ax"

src/internal/task/task_stack_arm.S

@@ -28,7 +28,7 @@ tinygo_startTask:
     blx   r4
 
     // After return, exit this goroutine. This is a tail call.
-    bl    tinygo_pause
+    bl    tinygo_task_exit
     .cfi_endproc
 .size tinygo_startTask, .-tinygo_startTask
 

src/internal/task/task_stack_arm64.S

@@ -2,7 +2,6 @@
 .global  _tinygo_startTask
 _tinygo_startTask:
 #else
-.section .text.tinygo_startTask
 .global  tinygo_startTask
 tinygo_startTask:
 #endif
@@ -28,9 +27,9 @@ tinygo_startTask:
 
     // After return, exit this goroutine. This is a tail call.
 #ifdef __MACH__
-    b     _tinygo_pause
+    b     _tinygo_task_exit
 #else
-    b     tinygo_pause
+    b     tinygo_task_exit
 #endif
     .cfi_endproc
 #ifndef __MACH__

src/internal/task/task_stack_avr.S

@@ -32,10 +32,10 @@ tinygo_startTask:
     // Note that they will probably not be able to run more than the main
     // goroutine anyway, but this file is compiled for all AVRs so it needs to
     // compile at least.
-    rcall  tinygo_pause
+    rcall  tinygo_task_exit
 #else
     // Other devices can (and must) use the regular call instruction.
-    call tinygo_pause
+    call tinygo_task_exit
 #endif
 
 .global tinygo_swapTask

src/internal/task/task_stack_cortexm.S

@@ -28,7 +28,7 @@ tinygo_startTask:
     blx   r4
 
     // After return, exit this goroutine. This is a tail call.
-    bl    	tinygo_pause
+    bl    	tinygo_task_exit
     .cfi_endproc
 .size tinygo_startTask, .-tinygo_startTask
 

src/internal/task/task_stack_esp32.S

@@ -27,7 +27,7 @@ tinygo_startTask:
     callx4 a3
 
     // After return, exit this goroutine. This call never returns.
-    call4  tinygo_pause
+    call4  tinygo_task_exit
 
 .section .text.tinygo_swapTask,"ax",@progbits
 .global tinygo_swapTask

src/internal/task/task_stack_esp8266.S

@@ -18,7 +18,7 @@ tinygo_startTask:
     callx0 a12
 
     // After return, exit this goroutine. This is a tail call.
-    call0  tinygo_pause
+    call0  tinygo_task_exit
 .size tinygo_startTask, .-tinygo_startTask
 
 .global tinygo_swapTask

src/internal/task/task_stack_mipsx.S

@@ -22,7 +22,7 @@ tinygo_startTask:
     nop
 
     // After return, exit this goroutine. This is a tail call.
-    j     tinygo_pause
+    j     tinygo_task_exit
     nop
 
 .section .text.tinygo_swapTask

src/internal/task/task_stack_tinygoriscv.S

@@ -19,7 +19,7 @@ tinygo_startTask:
     jalr  s0
 
     // After return, exit this goroutine. This is a tail call.
-    tail  tinygo_pause
+    tail  tinygo_task_exit
 
 .section .text.tinygo_swapTask
 .global  tinygo_swapTask

src/internal/task/task_threads.c

@@ -0,0 +1,113 @@
+//go:build none
+
+#define _GNU_SOURCE
+#include <pthread.h>
+#include <semaphore.h>
+#include <signal.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <unistd.h>
+
+// BDWGC also uses SIGRTMIN+6 on Linux, which seems like a reasonable choice.
+#ifdef __linux__
+#define taskPauseSignal (SIGRTMIN + 6)
+#endif
+
+// Pointer to the current task.Task structure.
+// Ideally the entire task.Task structure would be a thread-local variable but
+// this also works.
+static __thread void *current_task;
+
+struct state_pass {
+    void      *(*start)(void*);
+    void      *args;
+    void      *task;
+    uintptr_t *stackTop;
+    sem_t     startlock;
+};
+
+// Handle the GC pause in Go.
+void tinygo_task_gc_pause(int sig);
+
+// Initialize the main thread.
+void tinygo_task_init(void *mainTask, pthread_t *thread, int *numCPU, void *context) {
+    // Make sure the current task pointer is set correctly for the main
+    // goroutine as well.
+    current_task = mainTask;
+
+    // Store the thread ID of the main thread.
+    *thread = pthread_self();
+
+    // Register the "GC pause" signal for the entire process.
+    // Using pthread_kill, we can still send the signal to a specific thread.
+    struct sigaction act = { 0 };
+    act.sa_flags = SA_SIGINFO;
+    act.sa_handler = &tinygo_task_gc_pause;
+    sigaction(taskPauseSignal, &act, NULL);
+
+    // Obtain the number of CPUs available on program start (for NumCPU).
+    int num = sysconf(_SC_NPROCESSORS_ONLN);
+    if (num <= 0) {
+        // Fallback in case there is an error.
+        num = 1;
+    }
+    *numCPU = num;
+}
+
+void tinygo_task_exited(void*);
+
+// Helper to start a goroutine while also storing the 'task' structure.
+static void* start_wrapper(void *arg) {
+    struct state_pass *state = arg;
+    void *(*start)(void*) = state->start;
+    void *args = state->args;
+    current_task = state->task;
+
+    // Save the current stack pointer in the goroutine state, for the GC.
+    int stackAddr;
+    *(state->stackTop) = (uintptr_t)(&stackAddr);
+
+    // Notify the caller that the thread has successfully started and
+    // initialized.
+    sem_post(&state->startlock);
+
+    // Run the goroutine function.
+    start(args);
+
+    // Notify the Go side this thread will exit.
+    tinygo_task_exited(current_task);
+
+    return NULL;
+};
+
+// Start a new goroutine in an OS thread.
+int tinygo_task_start(uintptr_t fn, void *args, void *task, pthread_t *thread, uintptr_t *stackTop, void *context) {
+    // Sanity check. Should get optimized away.
+    if (sizeof(pthread_t) != sizeof(void*)) {
+        __builtin_trap();
+    }
+
+    struct state_pass state = {
+        .start     = (void*)fn,
+        .args      = args,
+        .task      = task,
+        .stackTop  = stackTop,
+    };
+    sem_init(&state.startlock, 0, 0);
+    int result = pthread_create(thread, NULL, &start_wrapper, &state);
+
+    // Wait until the thread has been created and read all state_pass variables.
+    sem_wait(&state.startlock);
+
+    return result;
+}
+
+// Return the current task (for task.Current()).
+void* tinygo_task_current(void) {
+    return current_task;
+}
+
+// Send a signal to cause the task to pause for the GC mark phase.
+void tinygo_task_send_gc_signal(pthread_t thread) {
+    pthread_kill(thread, taskPauseSignal);
+}

src/internal/task/task_threads.go

@@ -0,0 +1,281 @@
+//go:build scheduler.threads
+
+package task
+
+import (
+	"sync/atomic"
+	"unsafe"
+)
+
+// If true, print verbose debug logs.
+const verbose = false
+
+// Scheduler-specific state.
+type state struct {
+	// Goroutine ID. The number here is not really significant and after a while
+	// it could wrap around. But it is useful for debugging.
+	id uintptr
+
+	// Thread ID, pthread_t or similar (typically implemented as a pointer).
+	thread threadID
+
+	// Highest address of the stack. It is stored when the goroutine starts, and
+	// is needed to be able to scan the stack.
+	stackTop uintptr
+
+	// Next task in the activeTasks queue.
+	QueueNext *Task
+
+	// Semaphore to pause/resume the thread atomically.
+	pauseSem Semaphore
+
+	// Semaphore used for stack scanning.
+	// We can't reuse pauseSem here since the thread might have been paused for
+	// other reasons (for example, because it was waiting on a channel).
+	gcSem Semaphore
+}
+
+// Goroutine counter, starting at 0 for the main goroutine.
+var goroutineID uintptr
+
+var numCPU int32
+
+var mainTask Task
+
+// Queue of tasks (see QueueNext) that currently exist in the program.
+var activeTasks = &mainTask
+var activeTaskLock PMutex
+
+func OnSystemStack() bool {
+	runtimePanic("todo: task.OnSystemStack")
+	return false
+}
+
+// Initialize the main goroutine state. Must be called by the runtime on
+// startup, before starting any other goroutines.
+func Init(sp uintptr) {
+	mainTask.state.stackTop = sp
+	tinygo_task_init(&mainTask, &mainTask.state.thread, &numCPU)
+}
+
+// Return the task struct for the current thread.
+func Current() *Task {
+	t := (*Task)(tinygo_task_current())
+	if t == nil {
+		runtimePanic("unknown current task")
+	}
+	return t
+}
+
+// Pause pauses the current task, until it is resumed by another task.
+// It is possible that another task has called Resume() on the task before it
+// hits Pause(), in which case the task won't be paused but continues
+// immediately.
+func Pause() {
+	// Wait until resumed
+	t := Current()
+	if verbose {
+		println("*** pause:  ", t.state.id)
+	}
+	t.state.pauseSem.Wait()
+}
+
+// Resume the given task.
+// It is legal to resume a task before it gets paused, it means that the next
+// call to Pause() won't pause but will continue immediately. This happens in
+// practice sometimes in channel operations, where the Resume() might get called
+// between the channel unlock and the call to Pause().
+func (t *Task) Resume() {
+	if verbose {
+		println("*** resume: ", t.state.id)
+	}
+	// Increment the semaphore counter.
+	// If the task is currently paused in Wait(), it will resume.
+	// If the task is not yet paused, the next call to Wait() will continue
+	// immediately.
+	t.state.pauseSem.Post()
+}
+
+// Start a new OS thread.
+func start(fn uintptr, args unsafe.Pointer, stackSize uintptr) {
+	t := &Task{}
+	t.state.id = atomic.AddUintptr(&goroutineID, 1)
+	if verbose {
+		println("*** start:  ", t.state.id, "from", Current().state.id)
+	}
+
+	// Start the new thread, and add it to the list of threads.
+	// Do this with a lock so that only started threads are part of the queue
+	// and the stop-the-world GC won't see threads that haven't started yet or
+	// are not fully started yet.
+	activeTaskLock.Lock()
+	errCode := tinygo_task_start(fn, args, t, &t.state.thread, &t.state.stackTop)
+	if errCode != 0 {
+		runtimePanic("could not start thread")
+	}
+	t.state.QueueNext = activeTasks
+	activeTasks = t
+	activeTaskLock.Unlock()
+}
+
+//export tinygo_task_exited
+func taskExited(t *Task) {
+	if verbose {
+		println("*** exit:", t.state.id)
+	}
+
+	// Remove from the queue.
+	// TODO: this can be made more efficient by using a doubly linked list.
+	activeTaskLock.Lock()
+	found := false
+	for q := &activeTasks; *q != nil; q = &(*q).state.QueueNext {
+		if *q == t {
+			*q = t.state.QueueNext
+			found = true
+			break
+		}
+	}
+	activeTaskLock.Unlock()
+
+	// Sanity check.
+	if !found {
+		runtimePanic("taskExited failed")
+	}
+}
+
+// Futex to wait on until all tasks have finished scanning the stack.
+// This is basically a sync.WaitGroup.
+var scanDoneFutex Futex
+
+// GC scan phase. Because we need to stop the world while scanning, this kinda
+// needs to be done in the tasks package.
+//
+// After calling this function, GCResumeWorld needs to be called once to resume
+// all threads again.
+func GCStopWorldAndScan() {
+	current := Current()
+
+	// Don't allow new goroutines to be started while pausing/resuming threads
+	// in the stop-the-world phase.
+	activeTaskLock.Lock()
+
+	// Pause all other threads.
+	numOtherThreads := uint32(0)
+	for t := activeTasks; t != nil; t = t.state.QueueNext {
+		if t != current {
+			numOtherThreads++
+			tinygo_task_send_gc_signal(t.state.thread)
+		}
+	}
+
+	// Store the number of threads to wait for in the futex.
+	// This is the equivalent of doing an initial wg.Add(numOtherThreads).
+	scanDoneFutex.Store(numOtherThreads)
+
+	// Scan the current stack, and all current registers.
+	scanCurrentStack()
+
+	// Wake each paused thread for the first time so it will scan the stack.
+	for t := activeTasks; t != nil; t = t.state.QueueNext {
+		if t != current {
+			t.state.gcSem.Post()
+		}
+	}
+
+	// Wait until all threads have finished scanning their stack.
+	// This is the equivalent of wg.Wait()
+	for {
+		val := scanDoneFutex.Load()
+		if val == 0 {
+			break
+		}
+		scanDoneFutex.Wait(val)
+	}
+
+	// Scan all globals (implemented in the runtime).
+	gcScanGlobals()
+}
+
+// After the GC is done scanning, resume all other threads.
+//
+// This must only be called after a GCStopWorldAndScan call.
+func GCResumeWorld() {
+	current := Current()
+
+	// Wake each paused thread for the second time, so they will resume normal
+	// operation.
+	for t := activeTasks; t != nil; t = t.state.QueueNext {
+		if t != current {
+			t.state.gcSem.Post()
+		}
+	}
+
+	// Allow goroutines to start and exit again.
+	activeTaskLock.Unlock()
+}
+
+// Scan globals, implemented in the runtime package.
+func gcScanGlobals()
+
+var stackScanLock PMutex
+
+//export tinygo_task_gc_pause
+func tingyo_task_gc_pause() {
+	// Wait until we get the signal to start scanning the stack.
+	Current().state.gcSem.Wait()
+
+	// Scan the thread stack.
+	// Only scan a single thread stack at a time, because the GC marking phase
+	// doesn't support parallelism.
+	// TODO: it may be possible to call markRoots directly (without saving
+	// registers) since we are in a signal handler that already saved a bunch of
+	// registers. This is an optimization left for a future time.
+	stackScanLock.Lock()
+	scanCurrentStack()
+	stackScanLock.Unlock()
+
+	// Equivalent of wg.Done(): subtract one from the futex and if the result is
+	// 0 (meaning we were the last in the waitgroup), wake the waiting thread.
+	n := uint32(1)
+	if scanDoneFutex.Add(-n) == 0 {
+		scanDoneFutex.Wake()
+	}
+
+	// Wait until we get the signal we can resume normally (after the mark phase
+	// has finished).
+	Current().state.gcSem.Wait()
+}
+
+//go:export tinygo_scanCurrentStack
+func scanCurrentStack()
+
+// Return the highest address of the current stack.
+func StackTop() uintptr {
+	return Current().state.stackTop
+}
+
+//go:linkname runtimePanic runtime.runtimePanic
+func runtimePanic(msg string)
+
+// Using //go:linkname instead of //export so that we don't tell the compiler
+// that the 't' parameter won't escape (because it will).
+//
+//go:linkname tinygo_task_init tinygo_task_init
+func tinygo_task_init(t *Task, thread *threadID, numCPU *int32)
+
+// Here same as for tinygo_task_init.
+//
+//go:linkname tinygo_task_start tinygo_task_start
+func tinygo_task_start(fn uintptr, args unsafe.Pointer, t *Task, thread *threadID, stackTop *uintptr) int32
+
+// Pause the thread by sending it a signal.
+//
+//export tinygo_task_send_gc_signal
+func tinygo_task_send_gc_signal(threadID)
+
+//export tinygo_task_current
+func tinygo_task_current() unsafe.Pointer
+
+func NumCPU() int {
+	return int(numCPU)
+}

src/internal/wasi/cli/v0.2.0/exit/exit.wit.go

@@ -15,7 +15,7 @@ import (
 //
 //go:nosplit
 func Exit(status cm.BoolResult) {
-	status0 := cm.BoolToU32(status)
+	status0 := (uint32)(cm.BoolToU32(status))
 	wasmimport_Exit((uint32)(status0))
 	return
 }

src/internal/wasi/cli/v0.2.0/run/run.wasm.go

@@ -12,6 +12,6 @@ import (
 //export wasi:cli/run@0.2.0#run
 func wasmexport_Run() (result0 uint32) {
 	result := Exports.Run()
-	result0 = cm.BoolToU32(result)
+	result0 = (uint32)(cm.BoolToU32(result))
 	return
 }