ci: use native arm64 builder for arm64 binaries

ci: update GH actions builds to use Go 1.25.4
Signed-off-by: deadprogram <ron@hybridgroup.com>
2026-07-27 23:28:42 +00:00 · 2025-11-09 09:41:06 +01:00 · 2025-11-07 10:04:33 +01:00 · 2025-11-06 21:28:06 +01:00 · 2025-11-06 19:19:20 +01:00 · 2025-11-05 10:33:15 +01:00
51 changed files with 2745 additions and 131 deletions
@@ -39,7 +39,7 @@ jobs:
      - name: Install Go
        uses: actions/setup-go@v6
        with:
-          go-version: '1.25.1'
+          go-version: '1.25.4'
          cache: true
      - name: Restore LLVM source cache
        uses: actions/cache/restore@v4
@@ -96,7 +96,7 @@ jobs:
      - name: Build TinyGo release tarball
        run: make release -j3
      - name: Test stdlib packages
-        run: make tinygo-test
+        run: make tinygo-test TEST_ADDITIONAL_FLAGS="-scheduler=tasks"
      - name: Make release artifact
        run: cp -p build/release.tar.gz build/tinygo${{ steps.version.outputs.version }}.darwin-${{ matrix.goarch }}.tar.gz
      - name: Publish release artifact
@@ -134,7 +134,7 @@ jobs:
      - name: Install Go
        uses: actions/setup-go@v6
        with:
-          go-version: '1.25.1'
+          go-version: '1.25.4'
          cache: true
      - name: Build TinyGo (LLVM ${{ matrix.version }})
        run: go install -tags=llvm${{ matrix.version }}
@@ -31,7 +31,7 @@ jobs:
          sudo rm -rf /usr/local/share/boost
          df -h
      - name: Check out the repo
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
        with:
          submodules: recursive
      - name: Set up Docker Buildx
@@ -58,7 +58,7 @@ jobs:
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}
      - name: Build and push
-        uses: docker/build-push-action@v5
+        uses: docker/build-push-action@v6
        with:
          context: .
          push: true
@@ -16,7 +16,15 @@ jobs:
    # Build Linux binaries, ready for release.
    # This runs inside an Alpine Linux container so we can more easily create a
    # statically linked binary.
-    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        goarch: [ amd64, arm64 ]
+        include:
+          - goarch: amd64
+            os: ubuntu-latest
+          - goarch: arm64
+            os: ubuntu-24.04-arm # TODO: use a -latest variant?
+    runs-on: ${{ matrix.os }}
    container:
      image: golang:1.25-alpine
    outputs:
@@ -31,7 +39,7 @@ jobs:
        # We're not on a multi-user machine, so this is safe.
        run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
      - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
        with:
          submodules: true
      - name: Extract TinyGo version
@@ -40,7 +48,7 @@ jobs:
      - name: Cache Go
        uses: actions/cache@v4
        with:
-          key: go-cache-linux-alpine-v1-${{ hashFiles('go.mod') }}
+          key: go-cache-linux-alpine-${{ matrix.goarch }}-v1-${{ hashFiles('go.mod') }}
          path: |
            ~/.cache/go-build
            ~/go/pkg/mod
@@ -73,7 +81,7 @@ jobs:
        uses: actions/cache/restore@v4
        id: cache-llvm-build
        with:
-          key: llvm-build-20-linux-alpine-v1
+          key: llvm-build-19-linux-alpine-${{ matrix.goarch }}-v1
          path: llvm-build
      - name: Build LLVM
        if: steps.cache-llvm-build.outputs.cache-hit != 'true'
@@ -97,7 +105,7 @@ jobs:
        uses: actions/cache@v4
        id: cache-binaryen
        with:
-          key: binaryen-linux-alpine-v1
+          key: binaryen-linux-alpine-${{ matrix.goarch }}-v1
          path: build/wasm-opt
      - name: Build Binaryen
        if: steps.cache-binaryen.outputs.cache-hit != 'true'
@@ -116,28 +124,28 @@ jobs:
      - name: Build TinyGo release
        run: |
          make release deb -j3 STATIC=1
-          cp -p build/release.tar.gz /tmp/tinygo${{ steps.version.outputs.version }}.linux-amd64.tar.gz
-          cp -p build/release.deb    /tmp/tinygo_${{ steps.version.outputs.version }}_amd64.deb
+          cp -p build/release.tar.gz /tmp/tinygo${{ steps.version.outputs.version }}.linux-${{ matrix.goarch }}.tar.gz
+          cp -p build/release.deb    /tmp/tinygo_${{ steps.version.outputs.version }}_${{ matrix.goarch }}.deb
      - name: Publish release artifact
        uses: actions/upload-artifact@v4
        with:
-          name: linux-amd64-double-zipped-${{ steps.version.outputs.version }}
+          name: linux-${{ matrix.goarch }}-double-zipped-${{ steps.version.outputs.version }}
          path: |
-            /tmp/tinygo${{ steps.version.outputs.version }}.linux-amd64.tar.gz
-            /tmp/tinygo_${{ steps.version.outputs.version }}_amd64.deb
+            /tmp/tinygo${{ steps.version.outputs.version }}.linux-${{ matrix.goarch }}.tar.gz
+            /tmp/tinygo_${{ steps.version.outputs.version }}-${{ matrix.goarch }}.deb
  test-linux-build:
    # Test the binaries built in the build-linux job by running the smoke tests.
    runs-on: ubuntu-latest
    needs: build-linux
    steps:
      - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
        with:
          submodules: true
      - name: Install Go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v6
        with:
-          go-version: '1.25.0'
+          go-version: '1.25.4'
          cache: true
      - name: Install wasmtime
        uses: bytecodealliance/actions/wasmtime/setup@v1
@@ -164,7 +172,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
        with:
          submodules: true
      - name: Install apt dependencies
@@ -179,9 +187,9 @@ jobs:
              simavr \
              ninja-build
      - name: Install Go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v6
        with:
-          go-version: '1.25.0'
+          go-version: '1.25.4'
          cache: true
      - name: Install Node.js
        uses: actions/setup-node@v4
@@ -272,11 +280,8 @@ jobs:
    # part of the release tarball.
    strategy:
      matrix:
-        goarch: [ arm, arm64 ]
+        goarch: [ arm ]
        include:
-          - goarch: arm64
-            toolchain: aarch64-linux-gnu
-            libc: arm64
          - goarch: arm
            toolchain: arm-linux-gnueabihf
            libc: armhf
@@ -284,7 +289,7 @@ jobs:
    needs: build-linux
    steps:
      - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
      - name: Get TinyGo version
        id: version
        run: ./.github/workflows/tinygo-extract-version.sh | tee -a "$GITHUB_OUTPUT"
@@ -296,9 +301,9 @@ jobs:
              g++-${{ matrix.toolchain }} \
              libc6-dev-${{ matrix.libc }}-cross
      - name: Install Go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v6
        with:
-          go-version: '1.25.0'
+          go-version: '1.25.4'
          cache: true
      - name: Restore LLVM source cache
        uses: actions/cache/restore@v4
@@ -25,7 +25,7 @@ jobs:
      contents: read
    steps:
      - name: Check out the repo
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
        with:
          submodules: recursive
      - name: Set up Docker Buildx
@@ -52,7 +52,7 @@ jobs:
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}
      - name: Build and push
-        uses: docker/build-push-action@v5
+        uses: docker/build-push-action@v6
        with:
          target: tinygo-llvm-build
          context: .
@@ -21,7 +21,7 @@ jobs:
        # See: https://github.com/tinygo-org/tinygo/pull/4516#issuecomment-2416363668
        run: sudo apt-get remove llvm-18
      - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
      - name: Pull musl, bdwgc
        run: |
            git submodule update --init lib/musl lib/bdwgc
@@ -20,7 +20,7 @@ jobs:
        run: |
          echo "$HOME/go/bin" >> $GITHUB_PATH
      - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
        with:
          fetch-depth: 0 # fetch all history (no sparse checkout)
          submodules: true
@@ -31,7 +31,7 @@ jobs:
        run: |
          scoop install ninja binaryen
      - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
        with:
          submodules: true
      - name: Extract TinyGo version
@@ -39,9 +39,9 @@ jobs:
        shell: bash
        run: ./.github/workflows/tinygo-extract-version.sh | tee -a "$GITHUB_OUTPUT"
      - name: Install Go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v6
        with:
-          go-version: '1.25.0'
+          go-version: '1.25.4'
          cache: true
      - name: Restore cached LLVM source
        uses: actions/cache/restore@v4
@@ -143,11 +143,11 @@ jobs:
        run: |
          scoop install binaryen
      - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
      - name: Install Go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v6
        with:
-          go-version: '1.25.0'
+          go-version: '1.25.4'
          cache: true
      - name: Download TinyGo build
        uses: actions/download-artifact@v4
@@ -173,11 +173,11 @@ jobs:
          maximum-size: 24GB
          disk-root: "C:"
      - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
      - name: Install Go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v6
        with:
-          go-version: '1.25.0'
+          go-version: '1.25.4'
          cache: true
      - name: Download TinyGo build
        uses: actions/download-artifact@v4
@@ -209,11 +209,11 @@ jobs:
        run: |
          scoop install binaryen && scoop install wasmtime@29.0.1
      - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
      - name: Install Go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v6
        with:
-          go-version: '1.25.0'
+          go-version: '1.25.4'
          cache: true
      - name: Download TinyGo build
        uses: actions/download-artifact@v4
@@ -363,6 +363,7 @@ TEST_PACKAGES_FAST = \
 	path \
 	reflect \
 	sync \
+	testing \
 	testing/iotest \
 	text/scanner \
 	unicode \
@@ -479,7 +480,8 @@ TEST_PACKAGES_HOST := $(TEST_PACKAGES_FAST) $(TEST_PACKAGES_WINDOWS)
 TEST_IOFS := false
 endif

-TEST_SKIP_FLAG := -skip='TestExtraMethods|TestParseAndBytesRoundTrip/P256/Generic|^Fuzz'
+TEST_SKIP_FLAG := -skip='TestExtraMethods|TestParseAndBytesRoundTrip/P256/Generic'
+TEST_ADDITIONAL_FLAGS ?=

 # Test known-working standard library packages.
 # TODO: parallelize, and only show failing tests (no implied -v flag).
@@ -487,7 +489,7 @@ TEST_SKIP_FLAG := -skip='TestExtraMethods|TestParseAndBytesRoundTrip/P256/Generi
 tinygo-test:
 	@# TestExtraMethods: used by many crypto packages and uses reflect.Type.Method which is not implemented.
 	@# TestParseAndBytesRoundTrip/P256/Generic: relies on t.Skip() which is not implemented
-	$(TINYGO) test $(TEST_SKIP_FLAG) $(TEST_PACKAGES_HOST) $(TEST_PACKAGES_SLOW)
+	$(TINYGO) test $(TEST_ADDITIONAL_FLAGS) $(TEST_SKIP_FLAG) $(TEST_PACKAGES_HOST) $(TEST_PACKAGES_SLOW)
 	@# io/fs requires os.ReadDir, not yet supported on windows or wasi. It also
 	@# requires a large stack-size. Hence, io/fs is only run conditionally.
 	@# For more details, see the comments on issue #3143.
@@ -620,6 +622,8 @@ smoketest: testchdir
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=feather-rp2040      examples/device-id
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=pico2-ice           examples/blinky1
+	@$(MD5SUM) test.hex
 	# test simulated boards on play.tinygo.org
 ifneq ($(WASM), 0)
 	GOOS=js GOARCH=wasm $(TINYGO) build -size short -o test.wasm -tags=arduino              examples/blinky1
@@ -33,10 +33,13 @@ func NewConfig(options *compileopts.Options) (*compileopts.Config, error) {
 	if err != nil {
 		return nil, err
 	}
-	if gorootMajor != 1 || gorootMinor < minorMin || gorootMinor > minorMax {
-		// Note: when this gets updated, also update the Go compatibility matrix:
-		// https://github.com/tinygo-org/tinygo-site/blob/dev/content/docs/reference/go-compat-matrix.md
-		return nil, fmt.Errorf("requires go version 1.%d through 1.%d, got go%d.%d", minorMin, minorMax, gorootMajor, gorootMinor)
+
+	if options.GoCompatibility {
+		if gorootMajor != 1 || gorootMinor < minorMin || gorootMinor > minorMax {
+			// Note: when this gets updated, also update the Go compatibility matrix:
+			// https://github.com/tinygo-org/tinygo-site/blob/dev/content/docs/reference/go-compat-matrix.md
+			return nil, fmt.Errorf("requires go version 1.%d through 1.%d, got go%d.%d", minorMin, minorMax, gorootMajor, gorootMinor)
+		}
 	}

 	// Check that the Go toolchain version isn't too new, if we haven't been
@@ -43,8 +43,8 @@ func TestBinarySize(t *testing.T) {
 	tests := []sizeTest{
 		// microcontrollers
 		{"hifive1b", "examples/echo", 3884, 280, 0, 2268},
-		{"microbit", "examples/serial", 2852, 360, 8, 2272},
-		{"wioterminal", "examples/pininterrupt", 7337, 1491, 116, 6912},
+		{"microbit", "examples/serial", 2844, 360, 8, 2272},
+		{"wioterminal", "examples/pininterrupt", 7349, 1491, 116, 6912},

 		// TODO: also check wasm. Right now this is difficult, because
 		// wasm binaries are run through wasm-opt and therefore the
@@ -226,7 +226,7 @@ func (c *Config) StackSize() uint64 {

 // MaxStackAlloc returns the size of the maximum allocation to put on the stack vs heap.
 func (c *Config) MaxStackAlloc() uint64 {
-	if c.StackSize() > 32*1024 {
+	if c.StackSize() >= 16*1024 {
 		return 1024
 	}

@@ -59,6 +59,7 @@ type Options struct {
 	WITPackage      string // pass through to wasm-tools component embed invocation
 	WITWorld        string // pass through to wasm-tools component embed -w option
 	ExtLDFlags      []string
+	GoCompatibility bool // enable to check for Go version compatibility
 }

 // Verify performs a validation on the given options, raising an error if options are not valid.
@@ -32,6 +32,9 @@ const (
 	// Whether this is a full or partial Go parameter (int, slice, etc).
 	// The extra context parameter is not a Go parameter.
 	paramIsGoParam = 1 << iota
+
+	// Whether this is a readonly parameter (for example, a string pointer).
+	paramIsReadonly
 )

 // createRuntimeCallCommon creates a runtime call. Use createRuntimeCall or
@@ -167,6 +170,7 @@ func (c *compilerContext) flattenAggregateType(t llvm.Type, name string, goType
 				continue
 			}
 			suffix := strconv.Itoa(i)
+			isString := false
 			if goType != nil {
 				// Try to come up with a good suffix for this struct field,
 				// depending on which Go type it's based on.
@@ -183,12 +187,16 @@ func (c *compilerContext) flattenAggregateType(t llvm.Type, name string, goType
 						suffix = []string{"r", "i"}[i]
 					case types.String:
 						suffix = []string{"data", "len"}[i]
+						isString = true
 					}
 				case *types.Signature:
 					suffix = []string{"context", "funcptr"}[i]
 				}
 			}
 			subInfos := c.flattenAggregateType(subfield, name+"."+suffix, extractSubfield(goType, i))
+			if isString {
+				subInfos[0].flags |= paramIsReadonly
+			}
 			paramInfos = append(paramInfos, subInfos...)
 		}
 		return paramInfos
@@ -250,6 +250,9 @@ func (b *builder) createMapIteratorNext(rangeVal ssa.Value, llvmRangeVal, it llv
 func hashmapIsBinaryKey(keyType types.Type) bool {
 	switch keyType := keyType.Underlying().(type) {
 	case *types.Basic:
+		// TODO: unsafe.Pointer is also a binary key, but to support that we
+		// need to fix an issue with interp first (see
+		// https://github.com/tinygo-org/tinygo/pull/4898).
 		return keyType.Info()&(types.IsBoolean|types.IsInteger) != 0
 	case *types.Pointer:
 		return true
@@ -142,6 +142,11 @@ func (c *compilerContext) getFunction(fn *ssa.Function) (llvm.Type, llvm.Value)
 			nocapture := c.ctx.CreateEnumAttribute(llvm.AttributeKindID("nocapture"), 0)
 			llvmFn.AddAttributeAtIndex(i+1, nocapture)
 		}
+		if paramInfo.flags&paramIsReadonly != 0 && paramInfo.llvmType.TypeKind() == llvm.PointerTypeKind {
+			// Readonly pointer parameters (like strings) benefit from being marked as readonly.
+			readonly := c.ctx.CreateEnumAttribute(llvm.AttributeKindID("readonly"), 0)
+			llvmFn.AddAttributeAtIndex(i+1, readonly)
+		}
 	}

 	// Set a number of function or parameter attributes, depending on the
@@ -74,6 +74,14 @@ func (b *builder) createRawSyscall(call *ssa.CallCommon) (llvm.Value, error) {
 		return b.CreateCall(fnType, target, args, ""), nil

 	case b.GOARCH == "arm" && b.GOOS == "linux":
+		if arch := b.archFamily(); arch != "arm" {
+			// Some targets pretend to be linux/arm for compatibility but aren't
+			// actually such a system. Make sure we emit an error instead of
+			// creating inline assembly that will fail to compile.
+			// See: https://github.com/tinygo-org/tinygo/issues/4959
+			return llvm.Value{}, b.makeError(call.Pos(), "system calls are not supported: target emulates a linux/arm system on "+arch)
+		}
+
 		// Implement the EABI system call convention for Linux.
 		// Source: syscall(2) man page.
 		args := []llvm.Value{}
@@ -50,7 +50,7 @@ unsafe.String.throw:                              ; preds = %entry
 declare void @runtime.unsafeSlicePanic(ptr) #1

 ; Function Attrs: nounwind
-define hidden ptr @main.unsafeStringData(ptr %s.data, i32 %s.len, ptr %context) unnamed_addr #2 {
+define hidden ptr @main.unsafeStringData(ptr readonly %s.data, i32 %s.len, ptr %context) unnamed_addr #2 {
 entry:
  %stackalloc = alloca i8, align 1
  call void @runtime.trackPointer(ptr %s.data, ptr nonnull %stackalloc, ptr undef) #3
@@ -77,7 +77,7 @@ entry:
 }

 ; Function Attrs: nounwind
-define hidden %runtime._string @main.minString(ptr %a.data, i32 %a.len, ptr %b.data, i32 %b.len, ptr %context) unnamed_addr #2 {
+define hidden %runtime._string @main.minString(ptr readonly %a.data, i32 %a.len, ptr readonly %b.data, i32 %b.len, ptr %context) unnamed_addr #2 {
 entry:
  %0 = insertvalue %runtime._string zeroinitializer, ptr %a.data, 0
  %1 = insertvalue %runtime._string %0, i32 %a.len, 1
@@ -91,7 +91,7 @@ entry:
  ret %runtime._string %5
 }

-declare i1 @runtime.stringLess(ptr, i32, ptr, i32, ptr) #1
+declare i1 @runtime.stringLess(ptr readonly, i32, ptr readonly, i32, ptr) #1

 ; Function Attrs: nounwind
 define hidden i32 @main.maxInt(i32 %a, i32 %b, ptr %context) unnamed_addr #2 {
@@ -116,7 +116,7 @@ entry:
 }

 ; Function Attrs: nounwind
-define hidden %runtime._string @main.maxString(ptr %a.data, i32 %a.len, ptr %b.data, i32 %b.len, ptr %context) unnamed_addr #2 {
+define hidden %runtime._string @main.maxString(ptr readonly %a.data, i32 %a.len, ptr readonly %b.data, i32 %b.len, ptr %context) unnamed_addr #2 {
 entry:
  %0 = insertvalue %runtime._string zeroinitializer, ptr %a.data, 0
  %1 = insertvalue %runtime._string %0, i32 %a.len, 1
@@ -31,13 +31,13 @@ entry:
 }

 ; Function Attrs: nounwind
-define hidden i32 @main.stringLen(ptr %s.data, i32 %s.len, ptr %context) unnamed_addr #2 {
+define hidden i32 @main.stringLen(ptr readonly %s.data, i32 %s.len, ptr %context) unnamed_addr #2 {
 entry:
  ret i32 %s.len
 }

 ; Function Attrs: nounwind
-define hidden i8 @main.stringIndex(ptr %s.data, i32 %s.len, i32 %index, ptr %context) unnamed_addr #2 {
+define hidden i8 @main.stringIndex(ptr readonly %s.data, i32 %s.len, i32 %index, ptr %context) unnamed_addr #2 {
 entry:
  %.not = icmp ult i32 %index, %s.len
  br i1 %.not, label %lookup.next, label %lookup.throw
@@ -55,16 +55,16 @@ lookup.throw:                                     ; preds = %entry
 declare void @runtime.lookupPanic(ptr) #1

 ; Function Attrs: nounwind
-define hidden i1 @main.stringCompareEqual(ptr %s1.data, i32 %s1.len, ptr %s2.data, i32 %s2.len, ptr %context) unnamed_addr #2 {
+define hidden i1 @main.stringCompareEqual(ptr readonly %s1.data, i32 %s1.len, ptr readonly %s2.data, i32 %s2.len, ptr %context) unnamed_addr #2 {
 entry:
  %0 = call i1 @runtime.stringEqual(ptr %s1.data, i32 %s1.len, ptr %s2.data, i32 %s2.len, ptr undef) #3
  ret i1 %0
 }

-declare i1 @runtime.stringEqual(ptr, i32, ptr, i32, ptr) #1
+declare i1 @runtime.stringEqual(ptr readonly, i32, ptr readonly, i32, ptr) #1

 ; Function Attrs: nounwind
-define hidden i1 @main.stringCompareUnequal(ptr %s1.data, i32 %s1.len, ptr %s2.data, i32 %s2.len, ptr %context) unnamed_addr #2 {
+define hidden i1 @main.stringCompareUnequal(ptr readonly %s1.data, i32 %s1.len, ptr readonly %s2.data, i32 %s2.len, ptr %context) unnamed_addr #2 {
 entry:
  %0 = call i1 @runtime.stringEqual(ptr %s1.data, i32 %s1.len, ptr %s2.data, i32 %s2.len, ptr undef) #3
  %1 = xor i1 %0, true
@@ -72,16 +72,16 @@ entry:
 }

 ; Function Attrs: nounwind
-define hidden i1 @main.stringCompareLarger(ptr %s1.data, i32 %s1.len, ptr %s2.data, i32 %s2.len, ptr %context) unnamed_addr #2 {
+define hidden i1 @main.stringCompareLarger(ptr readonly %s1.data, i32 %s1.len, ptr readonly %s2.data, i32 %s2.len, ptr %context) unnamed_addr #2 {
 entry:
  %0 = call i1 @runtime.stringLess(ptr %s2.data, i32 %s2.len, ptr %s1.data, i32 %s1.len, ptr undef) #3
  ret i1 %0
 }

-declare i1 @runtime.stringLess(ptr, i32, ptr, i32, ptr) #1
+declare i1 @runtime.stringLess(ptr readonly, i32, ptr readonly, i32, ptr) #1

 ; Function Attrs: nounwind
-define hidden i8 @main.stringLookup(ptr %s.data, i32 %s.len, i8 %x, ptr %context) unnamed_addr #2 {
+define hidden i8 @main.stringLookup(ptr readonly %s.data, i32 %s.len, i8 %x, ptr %context) unnamed_addr #2 {
 entry:
  %0 = zext i8 %x to i32
  %.not = icmp ugt i32 %s.len, %0
@@ -256,6 +256,7 @@ func pathsToOverride(goMinor int, needsSyscallPackage bool) map[string]bool {
 		"reflect/":                    false,
 		"runtime/":                    false,
 		"sync/":                       true,
+		"testing/":                    true,
 		"tinygo/":                     false,
 		"unique/":                     false,
 	}
@@ -1635,6 +1635,7 @@ func main() {
 	cpuprofile := flag.String("cpuprofile", "", "cpuprofile output")
 	monitor := flag.Bool("monitor", false, "enable serial monitor")
 	baudrate := flag.Int("baudrate", 115200, "baudrate of serial monitor")
+	gocompatibility := flag.Bool("go-compatibility", true, "enable to check for Go versions compatibility, you can also configure this by setting the TINYGO_GOCOMPATIBILITY environment variable")

 	// Internal flags, that are only intended for TinyGo development.
 	printIR := flag.Bool("internal-printir", false, "print LLVM IR")
@@ -1712,6 +1713,16 @@ func main() {
 		ocdCommands = strings.Split(*ocdCommandsString, ",")
 	}

+	val, ok := os.LookupEnv("TINYGO_GOCOMPATIBILITY")
+	if ok {
+		b, err := strconv.ParseBool(val)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "could not parse TINYGO_GOCOMPATIBILITY value %q: %v\n", val, err)
+			os.Exit(1)
+		}
+		*gocompatibility = b
+	}
+
 	options := &compileopts.Options{
 		GOOS:            goenv.Get("GOOS"),
 		GOARCH:          goenv.Get("GOARCH"),
@@ -1748,6 +1759,7 @@ func main() {
 		Timeout:         *timeout,
 		WITPackage:      witPackage,
 		WITWorld:        witWorld,
+		GoCompatibility: *gocompatibility,
 	}
 	if *printCommands {
 		options.PrintCommands = printCommand
@@ -0,0 +1,173 @@
+//go:build pico2_ice
+
+// Most of the info is from
+// https://pico2-ice.tinyvision.ai/md_pinout.html although
+// (2025-09-07) RP4 appears twice in that pinout - the schematic is
+// more clear. Consistent with other RPi boards, we use GPn instead of
+// RPn to reference the RPi connected pins.
+
+package machine
+
+// GPIO pins
+const (
+	GP0  = GPIO0
+	GP1  = GPIO1
+	GP2  = GPIO2
+	GP3  = GPIO3
+	GP4  = GPIO4
+	GP5  = GPIO5
+	GP6  = GPIO6
+	GP7  = GPIO7
+	GP8  = GPIO8
+	GP9  = GPIO9
+	GP10 = GPIO10
+	GP11 = GPIO11
+	GP12 = GPIO12
+	GP13 = GPIO13
+	GP14 = GPIO14
+	GP15 = GPIO15
+	GP16 = GPIO16
+	GP17 = GPIO17
+	GP18 = GPIO18
+	GP19 = GPIO19
+	GP20 = GPIO20
+	GP21 = GPIO21
+	GP22 = GPIO22
+	GP23 = GPIO23
+	GP24 = GPIO24
+	GP25 = GPIO25
+	GP26 = GPIO26
+	GP27 = GPIO27
+	GP28 = GPIO28
+	GP29 = GPIO29
+	GP30 = GPIO30
+	GP31 = GPIO31
+	GP32 = GPIO32
+	GP33 = GPIO33
+	GP34 = GPIO34
+	GP35 = GPIO35
+	GP36 = GPIO36
+	GP37 = GPIO37
+	GP38 = GPIO38
+	GP39 = GPIO39
+	GP40 = GPIO40
+	GP41 = GPIO41
+	GP42 = GPIO42
+	GP43 = GPIO43
+	GP44 = GPIO44
+	GP45 = GPIO45
+	GP46 = GPIO46
+	GP47 = GPIO47
+
+	// RPi pins shared with ICE. The ICE number is what appears on
+	// the board silkscreen.
+	ICE9  = GP28
+	ICE11 = GP29
+	ICE14 = GP7
+	ICE15 = GP6
+	ICE16 = GP5
+	ICE17 = GP4
+	ICE18 = GP27
+	ICE19 = GP23
+	ICE20 = GP22
+	ICE21 = GP26
+	ICE23 = GP25
+	ICE25 = GP30
+	ICE26 = GP24
+	ICE27 = GP20
+
+	// FPGA Clock pin.
+	ICE35_G0 = GP21
+
+	// Silkscreen & Pinout names
+	ICE_SSN = ICE16
+	ICE_SO  = ICE14
+	ICE_SI  = ICE17
+	ICE_CK  = ICE15
+	SD      = GP2
+	SC      = GP3
+
+	FPGA_RSTN = GP31
+	A3        = GP32
+	A1        = GP33
+	A4        = GP34
+	A2        = GP35
+	B3        = GP36
+	B1        = GP37
+	B4        = GP38
+	B2        = GP39
+	N0        = GP40 // On the board these are labeled "~0"
+	N1        = GP41
+	N2        = GP42
+	N3        = GP43
+	N4        = GP44
+	N5        = GP45
+	N6        = GP46
+
+	// Functions from Schematic.
+	ICE_DONE = GP40
+	USB_BOOT = GP42
+
+	// Button
+	SW1     = GP42
+	BOOTSEL = GP42
+
+	// Tricolor LEDs
+	LED_RED   = GP1
+	LED_GREEN = GP0
+	LED_BLUE  = GP9
+
+	// Onboard LED
+	LED = LED_GREEN
+
+	// Onboard crystal oscillator frequency, in MHz.
+	xoscFreq = 12 // MHz
+)
+
+// This board does not define default i2c pins.
+const (
+	I2C0_SDA_PIN = NoPin
+	I2C0_SCL_PIN = NoPin
+	I2C1_SDA_PIN = NoPin
+	I2C1_SCL_PIN = NoPin
+)
+
+// SPI default pins
+const (
+	// Default Serial Clock Bus 0 for SPI communications
+	SPI0_SCK_PIN = GPIO18
+	// Default Serial Out Bus 0 for SPI communications
+	SPI0_SDO_PIN = GPIO19 // Tx
+	// Default Serial In Bus 0 for SPI communications
+	SPI0_SDI_PIN = GPIO16 // Rx
+
+	// Default Serial Clock Bus 1 for SPI communications
+	SPI1_SCK_PIN = GPIO10
+	// Default Serial Out Bus 1 for SPI communications
+	SPI1_SDO_PIN = GPIO11 // Tx
+	// Default Serial In Bus 1 for SPI communications
+	SPI1_SDI_PIN = GPIO12 // Rx
+)
+
+// UART pins
+const (
+	UART0_TX_PIN = GPIO0
+	UART0_RX_PIN = GPIO1
+	UART1_TX_PIN = GPIO8
+	UART1_RX_PIN = GPIO9
+	UART_TX_PIN  = UART0_TX_PIN
+	UART_RX_PIN  = UART0_RX_PIN
+)
+
+var DefaultUART = UART0
+
+// USB identifiers
+const (
+	usb_STRING_PRODUCT      = "Pico2"
+	usb_STRING_MANUFACTURER = "Raspberry Pi"
+)
+
+var (
+	usb_VID uint16 = 0x2E8A
+	usb_PID uint16 = 0x000A
+)
@@ -69,3 +69,5 @@ const eraseBlockSizeValue = 4096
 func eraseBlockSize() int64 {
 	return eraseBlockSizeValue
 }
+
+const spiMaxBufferSize = 255 // from the datasheet: TXD.MAXCNT and RXD.MAXCNT
@@ -90,3 +90,5 @@ const eraseBlockSizeValue = 4096
 func eraseBlockSize() int64 {
 	return eraseBlockSizeValue
 }
+
+const spiMaxBufferSize = 0xffff // from the datasheet: TXD.MAXCNT and RXD.MAXCNT
@@ -108,3 +108,5 @@ const eraseBlockSizeValue = 4096
 func eraseBlockSize() int64 {
 	return eraseBlockSizeValue
 }
+
+const spiMaxBufferSize = 0xffff // from the datasheet: TXD.MAXCNT and RXD.MAXCNT
@@ -301,18 +301,16 @@ func (spi *SPI) Transfer(w byte) (byte, error) {
 // padded until they fit: if len(w) > len(r) the extra bytes received will be
 // dropped and if len(w) < len(r) extra 0 bytes will be sent.
 func (spi *SPI) Tx(w, r []byte) error {
-	// Unfortunately the hardware (on the nrf52832) only supports up to 255
-	// bytes in the buffers, so if either w or r is longer than that the
-	// transfer needs to be broken up in pieces.
-	// The nrf52840 supports far larger buffers however, which isn't yet
-	// supported.
+	// Unfortunately the hardware (on the nrf52832) only supports a limited
+	// amount of bytes in the buffers (depending on the chip), so if either w or
+	// r is longer than that the transfer needs to be broken up in pieces.
 	for len(r) != 0 || len(w) != 0 {
 		// Prepare the SPI transfer: set the DMA pointers and lengths.
 		// read buffer
 		nr := uint32(len(r))
 		if nr > 0 {
-			if nr > 255 {
-				nr = 255
+			if nr > spiMaxBufferSize {
+				nr = spiMaxBufferSize
 			}
 			spi.Bus.RXD.PTR.Set(uint32(uintptr(unsafe.Pointer(&r[0]))))
 			r = r[nr:]
@@ -322,8 +320,8 @@ func (spi *SPI) Tx(w, r []byte) error {
 		// write buffer
 		nw := uint32(len(w))
 		if nw > 0 {
-			if nw > 255 {
-				nw = 255
+			if nw > spiMaxBufferSize {
+				nw = spiMaxBufferSize
 			}
 			spi.Bus.TXD.PTR.Set(uint32(uintptr(unsafe.Pointer(&w[0]))))
 			w = w[nw:]
@@ -124,6 +124,31 @@ const (
 	fnXIP pinFunc = 0
 )

+// validPins confirms that the SPI pin selection is a legitimate one
+// for the the 2040 chip.
+func (spi *SPI) validPins(config SPIConfig) error {
+	var okSDI, okSDO, okSCK bool
+	switch spi.Bus {
+	case rp.SPI0:
+		okSDI = config.SDI == 0 || config.SDI == 4 || config.SDI == 16 || config.SDI == 20
+		okSDO = config.SDO == 3 || config.SDO == 7 || config.SDO == 19 || config.SDO == 23
+		okSCK = config.SCK == 2 || config.SCK == 6 || config.SCK == 18 || config.SCK == 22
+	case rp.SPI1:
+		okSDI = config.SDI == 8 || config.SDI == 12 || config.SDI == 24 || config.SDI == 28
+		okSDO = config.SDO == 11 || config.SDO == 15 || config.SDO == 27
+		okSCK = config.SCK == 10 || config.SCK == 14 || config.SCK == 26
+	}
+	switch {
+	case !okSDI:
+		return errSPIInvalidSDI
+	case !okSDO:
+		return errSPIInvalidSDO
+	case !okSCK:
+		return errSPIInvalidSCK
+	}
+	return nil
+}
+
 // Configure configures the gpio pin as per mode.
 func (p Pin) Configure(config PinConfig) {
 	if p == NoPin {
@@ -2,6 +2,8 @@

 package machine

+import "device/rp"
+
 // Analog pins on RP2350a.
 const (
 	ADC0 Pin = GPIO26
@@ -12,3 +14,28 @@ const (
 	// fifth ADC channel.
 	thermADC = 30
 )
+
+// validPins confirms that the SPI pin selection is a legitimate one
+// for the the 2350a chip.
+func (spi *SPI) validPins(config SPIConfig) error {
+	var okSDI, okSDO, okSCK bool
+	switch spi.Bus {
+	case rp.SPI0:
+		okSDI = config.SDI == 0 || config.SDI == 4 || config.SDI == 16 || config.SDI == 20
+		okSDO = config.SDO == 3 || config.SDO == 7 || config.SDO == 19 || config.SDO == 23
+		okSCK = config.SCK == 2 || config.SCK == 6 || config.SCK == 18 || config.SCK == 22
+	case rp.SPI1:
+		okSDI = config.SDI == 8 || config.SDI == 12 || config.SDI == 24 || config.SDI == 28
+		okSDO = config.SDO == 11 || config.SDO == 15 || config.SDO == 27
+		okSCK = config.SCK == 10 || config.SCK == 14 || config.SCK == 26
+	}
+	switch {
+	case !okSDI:
+		return errSPIInvalidSDI
+	case !okSDO:
+		return errSPIInvalidSDO
+	case !okSCK:
+		return errSPIInvalidSCK
+	}
+	return nil
+}
@@ -2,6 +2,8 @@

 package machine

+import "device/rp"
+
 // RP2350B has additional pins.

 const (
@@ -46,3 +48,28 @@ var (
 	PWM10 = getPWMGroup(10)
 	PWM11 = getPWMGroup(11)
 )
+
+// validPins confirms that the SPI pin selection is a legitimate one
+// for the the 2350b chip.
+func (spi *SPI) validPins(config SPIConfig) error {
+	var okSDI, okSDO, okSCK bool
+	switch spi.Bus {
+	case rp.SPI0:
+		okSDI = config.SDI == 0 || config.SDI == 4 || config.SDI == 16 || config.SDI == 20 || config.SDI == 32 || config.SDI == 36
+		okSDO = config.SDO == 3 || config.SDO == 7 || config.SDO == 19 || config.SDO == 23 || config.SDO == 35 || config.SDO == 39
+		okSCK = config.SCK == 2 || config.SCK == 6 || config.SCK == 18 || config.SCK == 22 || config.SCK == 34 || config.SCK == 38
+	case rp.SPI1:
+		okSDI = config.SDI == 8 || config.SDI == 12 || config.SDI == 24 || config.SDI == 28 || config.SDI == 40 || config.SDI == 44
+		okSDO = config.SDO == 11 || config.SDO == 15 || config.SDO == 27 || config.SDO == 31 || config.SDO == 43 || config.SDO == 47
+		okSCK = config.SCK == 10 || config.SCK == 14 || config.SCK == 26 || config.SCK == 30 || config.SCK == 42 || config.SCK == 46
+	}
+	switch {
+	case !okSDI:
+		return errSPIInvalidSDI
+	case !okSDO:
+		return errSPIInvalidSDO
+	case !okSCK:
+		return errSPIInvalidSCK
+	}
+	return nil
+}
@@ -108,7 +108,7 @@ func (spi *SPI) SetBaudRate(br uint32) error {
 	var prescale, postdiv uint32
 	freq := CPUFrequency()
 	for prescale = 2; prescale < 255; prescale += 2 {
-		if freq < (prescale+2)*256*br {
+		if uint64(freq) < uint64((prescale+2)*256)*uint64(br) {
 			break
 		}
 	}
@@ -165,27 +165,9 @@ func (spi *SPI) Configure(config SPIConfig) error {
 			config.SDI = SPI1_SDI_PIN
 		}
 	}
-	var okSDI, okSDO, okSCK bool
-	switch spi.Bus {
-	case rp.SPI0:
-		okSDI = config.SDI == 0 || config.SDI == 4 || config.SDI == 16 || config.SDI == 20
-		okSDO = config.SDO == 3 || config.SDO == 7 || config.SDO == 19 || config.SDO == 23
-		okSCK = config.SCK == 2 || config.SCK == 6 || config.SCK == 18 || config.SCK == 22
-	case rp.SPI1:
-		okSDI = config.SDI == 8 || config.SDI == 12 || config.SDI == 24 || config.SDI == 28
-		okSDO = config.SDO == 11 || config.SDO == 15 || config.SDO == 27
-		okSCK = config.SCK == 10 || config.SCK == 14 || config.SCK == 26
+	if err := spi.validPins(config); err != nil {
+		return err
 	}
-
-	switch {
-	case !okSDI:
-		return errSPIInvalidSDI
-	case !okSDO:
-		return errSPIInvalidSDO
-	case !okSCK:
-		return errSPIInvalidSCK
-	}
-
 	if config.Frequency == 0 {
 		config.Frequency = defaultBaud
 	}
@@ -8,16 +8,21 @@ import "unsafe"
 // code linked from other languages can allocate memory without colliding with
 // our GC allocations.

-var allocs = make(map[uintptr][]byte)
+// Map of allocations, where the key is the allocated pointer and the value is
+// the size of the allocation.
+// TODO: make this a map[unsafe.Pointer]uintptr, since that results in slightly
+// smaller binaries. But for that to work, unsafe.Pointer needs to be seen as a
+// binary key (which it is not at the moment).
+// See https://github.com/tinygo-org/tinygo/pull/4898 for details.
+var allocs = make(map[*byte]uintptr)

 //export malloc
 func libc_malloc(size uintptr) unsafe.Pointer {
 	if size == 0 {
 		return nil
 	}
-	buf := make([]byte, size)
-	ptr := unsafe.Pointer(&buf[0])
-	allocs[uintptr(ptr)] = buf
+	ptr := alloc(size, nil)
+	allocs[(*byte)(ptr)] = size
 	return ptr
 }

@@ -26,8 +31,8 @@ func libc_free(ptr unsafe.Pointer) {
 	if ptr == nil {
 		return
 	}
-	if _, ok := allocs[uintptr(ptr)]; ok {
-		delete(allocs, uintptr(ptr))
+	if _, ok := allocs[(*byte)(ptr)]; ok {
+		delete(allocs, (*byte)(ptr))
 	} else {
 		panic("free: invalid pointer")
 	}
@@ -48,18 +53,20 @@ func libc_realloc(oldPtr unsafe.Pointer, size uintptr) unsafe.Pointer {

 	// It's hard to optimize this to expand the current buffer with our GC, but
 	// it is theoretically possible. For now, just always allocate fresh.
-	buf := make([]byte, size)
+	// TODO: we could skip this if the new allocation is smaller than the old.
+	ptr := alloc(size, nil)

 	if oldPtr != nil {
-		if oldBuf, ok := allocs[uintptr(oldPtr)]; ok {
-			copy(buf, oldBuf)
-			delete(allocs, uintptr(oldPtr))
+		if oldSize, ok := allocs[(*byte)(oldPtr)]; ok {
+			oldBuf := unsafe.Slice((*byte)(oldPtr), oldSize)
+			newBuf := unsafe.Slice((*byte)(ptr), size)
+			copy(newBuf, oldBuf)
+			delete(allocs, (*byte)(oldPtr))
 		} else {
 			panic("realloc: invalid pointer")
 		}
 	}

-	ptr := unsafe.Pointer(&buf[0])
-	allocs[uintptr(ptr)] = buf
+	allocs[(*byte)(ptr)] = size
 	return ptr
 }
@@ -30,9 +30,7 @@ func SetPanicOnFault(enabled bool) bool {

 func WriteHeapDump(fd uintptr)

-// Unimplemented.
-func SetTraceback(level string) {
-}
+func SetTraceback(level string)

 func SetMemoryLimit(limit int64) int64 {
 	return limit
@@ -1,11 +1,6 @@
 package runtime

 func Callers(skip int, pc []uintptr) int {
-	if len(pc) > 0 {
-		// The testing package expects at least one caller in all cases.
-		pc[0] = 0
-		return 1
-	}
 	return 0
 }

@@ -181,19 +181,3 @@ func getAuxv() []uintptr {
 func cgo_errno() uintptr {
 	return uintptr(*libc_errno_location())
 }
-
-// Unimplemented.
-var MemProfileRate int = 0
-
-// Unimplemented.
-func SetBlockProfileRate(rate int) {
-}
-
-var mutexProfileFraction int
-
-// Unimplemented.
-func SetMutexProfileFraction(rate int) int {
-	previous := mutexProfileFraction
-	mutexProfileFraction = rate
-	return previous
-}
@@ -273,6 +273,9 @@ func nanosecondsToTicks(ns int64) timeUnit {
 func sleepTicks(d timeUnit) {
 	for d != 0 {
 		ticks := uint32(d)
+		if d > 0xffff_ffff {
+			ticks = 0xffff_ffff
+		}
 		if !timerSleep(ticks) {
 			// Bail out early to handle a non-time interrupt.
 			return
@@ -266,6 +266,9 @@ func nanosecondsToTicks(ns int64) timeUnit {
 func sleepTicks(d timeUnit) {
 	for d != 0 {
 		ticks := uint32(d)
+		if d > 0xffff_ffff {
+			ticks = 0xffff_ffff
+		}
 		if !timerSleep(ticks) {
 			return
 		}
@@ -78,6 +78,9 @@ func buffered() int {
 func sleepTicks(d timeUnit) {
 	for d != 0 {
 		ticks := uint32(d) & 0x7fffff // 23 bits (to be on the safe side)
+		if d > 0x7fffff {
+			ticks = 0x7fffff
+		}
 		rtc_sleep(ticks)
 		d -= timeUnit(ticks)
 	}
@@ -81,6 +81,9 @@ func buffered() int {
 func sleepTicks(d timeUnit) {
 	for d != 0 {
 		ticks := uint32(d) & 0x7fffff // 23 bits (to be on the safe side)
+		if d > 0x7fffff {
+			ticks = 0x7fffff
+		}
 		rtc_sleep(ticks)
 		d -= timeUnit(ticks)
 	}
@@ -212,6 +212,7 @@ func writeStream(stream *wasiStream, buf *byte, count uint, offset int64) int {
 			return -1
 		}
 		remaining -= len
+		src = src[len:]
 	}

 	return int(count)
@@ -0,0 +1,521 @@
+// 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.
+//
+// This file has been modified for use by the TinyGo compiler.
+
+package testing
+
+import (
+	"flag"
+	"fmt"
+	"io"
+	"math"
+	"os"
+	"runtime"
+	"strconv"
+	"strings"
+	"time"
+)
+
+func initBenchmarkFlags() {
+	matchBenchmarks = flag.String("test.bench", "", "run only benchmarks matching `regexp`")
+	benchmarkMemory = flag.Bool("test.benchmem", false, "print memory allocations for benchmarks")
+	flag.Var(&benchTime, "test.benchtime", "run each benchmark for duration `d`")
+}
+
+var (
+	matchBenchmarks *string
+	benchmarkMemory *bool
+	benchTime       = benchTimeFlag{d: 1 * time.Second} // changed during test of testing package
+)
+
+type benchTimeFlag struct {
+	d time.Duration
+	n int
+}
+
+func (f *benchTimeFlag) String() string {
+	if f.n > 0 {
+		return fmt.Sprintf("%dx", f.n)
+	}
+	return time.Duration(f.d).String()
+}
+
+func (f *benchTimeFlag) Set(s string) error {
+	if strings.HasSuffix(s, "x") {
+		n, err := strconv.ParseInt(s[:len(s)-1], 10, 0)
+		if err != nil || n <= 0 {
+			return fmt.Errorf("invalid count")
+		}
+		*f = benchTimeFlag{n: int(n)}
+		return nil
+	}
+	d, err := time.ParseDuration(s)
+	if err != nil || d <= 0 {
+		return fmt.Errorf("invalid duration")
+	}
+	*f = benchTimeFlag{d: d}
+	return nil
+}
+
+// InternalBenchmark is an internal type but exported because it is cross-package;
+// it is part of the implementation of the "go test" command.
+type InternalBenchmark struct {
+	Name string
+	F    func(b *B)
+}
+
+// B is a type passed to Benchmark functions to manage benchmark
+// timing and to specify the number of iterations to run.
+//
+// A benchmark ends when its Benchmark function returns or calls any of the methods
+// FailNow, Fatal, Fatalf, SkipNow, Skip, or Skipf. Those methods must be called
+// only from the goroutine running the Benchmark function.
+// The other reporting methods, such as the variations of Log and Error,
+// may be called simultaneously from multiple goroutines.
+//
+// Like in tests, benchmark logs are accumulated during execution
+// and dumped to standard output when done. Unlike in tests, benchmark logs
+// are always printed, so as not to hide output whose existence may be
+// affecting benchmark results.
+type B struct {
+	common
+	context      *benchContext
+	N            int
+	benchFunc    func(b *B)
+	bytes        int64
+	missingBytes bool // one of the subbenchmarks does not have bytes set.
+	benchTime    benchTimeFlag
+	timerOn      bool
+	result       BenchmarkResult
+
+	// report memory statistics
+	showAllocResult bool
+	// initial state of MemStats.Mallocs and MemStats.TotalAlloc
+	startAllocs uint64
+	startBytes  uint64
+	// net total after running benchmar
+	netAllocs uint64
+	netBytes  uint64
+}
+
+// StartTimer starts timing a test. This function is called automatically
+// before a benchmark starts, but it can also be used to resume timing after
+// a call to StopTimer.
+func (b *B) StartTimer() {
+	if !b.timerOn {
+		b.start = time.Now()
+		b.timerOn = true
+
+		var mstats runtime.MemStats
+		runtime.ReadMemStats(&mstats)
+		b.startAllocs = mstats.Mallocs
+		b.startBytes = mstats.TotalAlloc
+	}
+}
+
+// StopTimer stops timing a test. This can be used to pause the timer
+// while performing complex initialization that you don't
+// want to measure.
+func (b *B) StopTimer() {
+	if b.timerOn {
+		b.duration += time.Since(b.start)
+		b.timerOn = false
+
+		var mstats runtime.MemStats
+		runtime.ReadMemStats(&mstats)
+		b.netAllocs += mstats.Mallocs - b.startAllocs
+		b.netBytes += mstats.TotalAlloc - b.startBytes
+	}
+}
+
+// ResetTimer zeroes the elapsed benchmark time and memory allocation counters
+// and deletes user-reported metrics.
+func (b *B) ResetTimer() {
+	if b.timerOn {
+		b.start = time.Now()
+
+		var mstats runtime.MemStats
+		runtime.ReadMemStats(&mstats)
+		b.startAllocs = mstats.Mallocs
+		b.startBytes = mstats.TotalAlloc
+	}
+	b.duration = 0
+	b.netAllocs = 0
+	b.netBytes = 0
+}
+
+// SetBytes records the number of bytes processed in a single operation.
+// If this is called, the benchmark will report ns/op and MB/s.
+func (b *B) SetBytes(n int64) { b.bytes = n }
+
+// ReportAllocs enables malloc statistics for this benchmark.
+// It is equivalent to setting -test.benchmem, but it only affects the
+// benchmark function that calls ReportAllocs.
+func (b *B) ReportAllocs() {
+	b.showAllocResult = true
+}
+
+// runN runs a single benchmark for the specified number of iterations.
+func (b *B) runN(n int) {
+	b.N = n
+	runtime.GC()
+	b.ResetTimer()
+	b.StartTimer()
+	b.benchFunc(b)
+	b.StopTimer()
+}
+
+func min(x, y int64) int64 {
+	if x > y {
+		return y
+	}
+	return x
+}
+
+func max(x, y int64) int64 {
+	if x < y {
+		return y
+	}
+	return x
+}
+
+// run1 runs the first iteration of benchFunc. It reports whether more
+// iterations of this benchmarks should be run.
+func (b *B) run1() bool {
+	if ctx := b.context; ctx != nil {
+		// Extend maxLen, if needed.
+		if n := len(b.name); n > ctx.maxLen {
+			ctx.maxLen = n + 8 // Add additional slack to avoid too many jumps in size.
+		}
+	}
+	b.runN(1)
+	return !b.hasSub
+}
+
+// run executes the benchmark.
+func (b *B) run() {
+	if b.context != nil {
+		// Running go test --test.bench
+		b.processBench(b.context) // calls doBench and prints results
+	} else {
+		// Running func Benchmark.
+		b.doBench()
+	}
+}
+
+func (b *B) doBench() BenchmarkResult {
+	// in upstream, this uses a goroutine
+	b.launch()
+	return b.result
+}
+
+// launch launches the benchmark function. It gradually increases the number
+// of benchmark iterations until the benchmark runs for the requested benchtime.
+// run1 must have been called on b.
+func (b *B) launch() {
+	// Run the benchmark for at least the specified amount of time.
+	if b.benchTime.n > 0 {
+		b.runN(b.benchTime.n)
+	} else {
+		d := b.benchTime.d
+		b.failed = false
+		b.duration = 0
+		for n := int64(1); !b.failed && b.duration < d && n < 1e9; {
+			last := n
+			// Predict required iterations.
+			goalns := d.Nanoseconds()
+			prevIters := int64(b.N)
+			prevns := b.duration.Nanoseconds()
+			if prevns <= 0 {
+				// Round up, to avoid div by zero.
+				prevns = 1
+			}
+			// Order of operations matters.
+			// For very fast benchmarks, prevIters ~= prevns.
+			// If you divide first, you get 0 or 1,
+			// which can hide an order of magnitude in execution time.
+			// So multiply first, then divide.
+			n = goalns * prevIters / prevns
+			// Run more iterations than we think we'll need (1.2x).
+			n += n / 5
+			// Don't grow too fast in case we had timing errors previously.
+			n = min(n, 100*last)
+			// Be sure to run at least one more than last time.
+			n = max(n, last+1)
+			// Don't run more than 1e9 times. (This also keeps n in int range on 32 bit platforms.)
+			n = min(n, 1e9)
+			b.runN(int(n))
+		}
+	}
+	b.result = BenchmarkResult{b.N, b.duration, b.bytes, b.netAllocs, b.netBytes}
+}
+
+// BenchmarkResult contains the results of a benchmark run.
+type BenchmarkResult struct {
+	N     int           // The number of iterations.
+	T     time.Duration // The total time taken.
+	Bytes int64         // Bytes processed in one iteration.
+
+	MemAllocs uint64 // The total number of memory allocations.
+	MemBytes  uint64 // The total number of bytes allocated.
+}
+
+// NsPerOp returns the "ns/op" metric.
+func (r BenchmarkResult) NsPerOp() int64 {
+	if r.N <= 0 {
+		return 0
+	}
+	return r.T.Nanoseconds() / int64(r.N)
+}
+
+// mbPerSec returns the "MB/s" metric.
+func (r BenchmarkResult) mbPerSec() float64 {
+	if r.Bytes <= 0 || r.T <= 0 || r.N <= 0 {
+		return 0
+	}
+	return (float64(r.Bytes) * float64(r.N) / 1e6) / r.T.Seconds()
+}
+
+// AllocsPerOp returns the "allocs/op" metric,
+// which is calculated as r.MemAllocs / r.N.
+func (r BenchmarkResult) AllocsPerOp() int64 {
+	if r.N <= 0 {
+		return 0
+	}
+	return int64(r.MemAllocs) / int64(r.N)
+}
+
+// AllocedBytesPerOp returns the "B/op" metric,
+// which is calculated as r.MemBytes / r.N.
+func (r BenchmarkResult) AllocedBytesPerOp() int64 {
+	if r.N <= 0 {
+		return 0
+	}
+	return int64(r.MemBytes) / int64(r.N)
+}
+
+// String returns a summary of the benchmark results.
+// It follows the benchmark result line format from
+// https://golang.org/design/14313-benchmark-format, not including the
+// benchmark name.
+// Extra metrics override built-in metrics of the same name.
+// String does not include allocs/op or B/op, since those are reported
+// by MemString.
+func (r BenchmarkResult) String() string {
+	buf := new(strings.Builder)
+	fmt.Fprintf(buf, "%8d", r.N)
+
+	// Get ns/op as a float.
+	ns := float64(r.T.Nanoseconds()) / float64(r.N)
+	if ns != 0 {
+		buf.WriteByte('\t')
+		prettyPrint(buf, ns, "ns/op")
+	}
+
+	if mbs := r.mbPerSec(); mbs != 0 {
+		fmt.Fprintf(buf, "\t%7.2f MB/s", mbs)
+	}
+	return buf.String()
+}
+
+// MemString returns r.AllocedBytesPerOp and r.AllocsPerOp in the same format as 'go test'.
+func (r BenchmarkResult) MemString() string {
+	return fmt.Sprintf("%8d B/op\t%8d allocs/op",
+		r.AllocedBytesPerOp(), r.AllocsPerOp())
+}
+
+func prettyPrint(w io.Writer, x float64, unit string) {
+	// Print all numbers with 10 places before the decimal point
+	// and small numbers with four sig figs. Field widths are
+	// chosen to fit the whole part in 10 places while aligning
+	// the decimal point of all fractional formats.
+	var format string
+	switch y := math.Abs(x); {
+	case y == 0 || y >= 999.95:
+		format = "%10.0f %s"
+	case y >= 99.995:
+		format = "%12.1f %s"
+	case y >= 9.9995:
+		format = "%13.2f %s"
+	case y >= 0.99995:
+		format = "%14.3f %s"
+	case y >= 0.099995:
+		format = "%15.4f %s"
+	case y >= 0.0099995:
+		format = "%16.5f %s"
+	case y >= 0.00099995:
+		format = "%17.6f %s"
+	default:
+		format = "%18.7f %s"
+	}
+	fmt.Fprintf(w, format, x, unit)
+}
+
+type benchContext struct {
+	match *matcher
+
+	maxLen int // The largest recorded benchmark name.
+}
+
+func runBenchmarks(matchString func(pat, str string) (bool, error), benchmarks []InternalBenchmark) bool {
+	// If no flag was specified, don't run benchmarks.
+	if len(*matchBenchmarks) == 0 {
+		return true
+	}
+	ctx := &benchContext{
+		match: newMatcher(matchString, *matchBenchmarks, "-test.bench", flagSkipRegexp),
+	}
+	var bs []InternalBenchmark
+	for _, Benchmark := range benchmarks {
+		if _, matched, _ := ctx.match.fullName(nil, Benchmark.Name); matched {
+			bs = append(bs, Benchmark)
+			benchName := Benchmark.Name
+			if l := len(benchName); l > ctx.maxLen {
+				ctx.maxLen = l
+			}
+		}
+	}
+	main := &B{
+		common: common{
+			output: &logger{},
+			name:   "Main",
+		},
+		benchTime: benchTime,
+		benchFunc: func(b *B) {
+			for _, Benchmark := range bs {
+				b.Run(Benchmark.Name, Benchmark.F)
+			}
+		},
+		context: ctx,
+	}
+
+	main.runN(1)
+	return true
+}
+
+// processBench runs bench b and prints the results.
+func (b *B) processBench(ctx *benchContext) {
+	benchName := b.name
+
+	for i := 0; i < flagCount; i++ {
+		if ctx != nil {
+			fmt.Printf("%-*s\t", ctx.maxLen, benchName)
+		}
+		r := b.doBench()
+		if b.failed {
+			// The output could be very long here, but probably isn't.
+			// We print it all, regardless, because we don't want to trim the reason
+			// the benchmark failed.
+			fmt.Printf("--- FAIL: %s\n%s", benchName, "") // b.output)
+			return
+		}
+		if ctx != nil {
+			results := r.String()
+
+			if *benchmarkMemory || b.showAllocResult {
+				results += "\t" + r.MemString()
+			}
+			fmt.Println(results)
+
+			// Print any benchmark output
+			if b.output.Len() > 0 {
+				fmt.Printf("--- BENCH: %s\n", benchName)
+				b.output.WriteTo(os.Stdout)
+			}
+		}
+	}
+}
+
+// Run benchmarks f as a subbenchmark with the given name. It reports
+// true if the subbenchmark succeeded.
+//
+// A subbenchmark is like any other benchmark. A benchmark that calls Run at
+// least once will not be measured itself and will be called once with N=1.
+func (b *B) Run(name string, f func(b *B)) bool {
+	benchName, ok, partial := b.name, true, false
+	if b.context != nil {
+		benchName, ok, partial = b.context.match.fullName(&b.common, name)
+	}
+	if !ok {
+		return true
+	}
+	b.hasSub = true
+	sub := &B{
+		common: common{
+			output: &logger{},
+			name:   benchName,
+			level:  b.level + 1,
+		},
+		benchFunc: f,
+		benchTime: b.benchTime,
+		context:   b.context,
+	}
+	if partial {
+		// Partial name match, like -bench=X/Y matching BenchmarkX.
+		// Only process sub-benchmarks, if any.
+		sub.hasSub = true
+	}
+	if sub.run1() {
+		sub.run()
+	}
+	b.add(sub.result)
+	return !sub.failed
+}
+
+// add simulates running benchmarks in sequence in a single iteration. It is
+// used to give some meaningful results in case func Benchmark is used in
+// combination with Run.
+func (b *B) add(other BenchmarkResult) {
+	r := &b.result
+	// The aggregated BenchmarkResults resemble running all subbenchmarks as
+	// in sequence in a single benchmark.
+	r.N = 1
+	r.T += time.Duration(other.NsPerOp())
+	if other.Bytes == 0 {
+		// Summing Bytes is meaningless in aggregate if not all subbenchmarks
+		// set it.
+		b.missingBytes = true
+		r.Bytes = 0
+	}
+	if !b.missingBytes {
+		r.Bytes += other.Bytes
+	}
+}
+
+// A PB is used by RunParallel for running parallel benchmarks.
+type PB struct {
+}
+
+// Next reports whether there are more iterations to execute.
+func (pb *PB) Next() bool {
+	return false
+}
+
+// RunParallel runs a benchmark in parallel.
+//
+// Not implemented
+func (b *B) RunParallel(body func(*PB)) {
+	return
+}
+
+func (b *B) Loop() bool {
+	panic("unimplemented: testing.B.Loop")
+}
+
+// Benchmark benchmarks a single function. It is useful for creating
+// custom benchmarks that do not use the "go test" command.
+//
+// If f calls Run, the result will be an estimate of running all its
+// subbenchmarks that don't call Run in sequence in a single benchmark.
+func Benchmark(f func(b *B)) BenchmarkResult {
+	b := &B{
+		benchFunc: f,
+		benchTime: benchTime,
+	}
+	if b.run1() {
+		b.run()
+	}
+	return b.result
+}
@@ -0,0 +1,55 @@
+// Copyright 2011 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 testing_test
+
+import (
+	"testing"
+)
+
+var buf = make([]byte, 13579)
+
+func NonASCII(b []byte, i int, offset int) int {
+	for i = offset; i < len(b)+offset; i++ {
+		if b[i%len(b)] >= 0x80 {
+			break
+		}
+	}
+	return i
+}
+
+func BenchmarkFastNonASCII(b *testing.B) {
+	var val int
+	for i := 0; i < b.N; i++ {
+		val += NonASCII(buf, 0, 0)
+	}
+}
+
+func BenchmarkSlowNonASCII(b *testing.B) {
+	var val int
+	for i := 0; i < b.N; i++ {
+		val += NonASCII(buf, 0, 0)
+		val += NonASCII(buf, 0, 1)
+	}
+}
+
+// TestBenchmark simply uses Benchmark twice and makes sure it does not crash.
+func TestBenchmark(t *testing.T) {
+	// FIXME: reduce runtime from the current 3 seconds.
+	rslow := testing.Benchmark(BenchmarkSlowNonASCII)
+	rfast := testing.Benchmark(BenchmarkFastNonASCII)
+	tslow := rslow.NsPerOp()
+	tfast := rfast.NsPerOp()
+
+	// Be exceedingly forgiving; do not fail even if system gets busy.
+	speedup := float64(tslow) / float64(tfast)
+	if speedup < 0.3 {
+		t.Errorf("Expected speedup >= 0.3, got %f", speedup)
+	}
+}
+
+func BenchmarkSub(b *testing.B) {
+	b.Run("Fast", func(b *testing.B) { BenchmarkFastNonASCII(b) })
+	b.Run("Slow", func(b *testing.B) { BenchmarkSlowNonASCII(b) })
+}
@@ -0,0 +1,6 @@
+package testing
+
+/*
+ This is a sad stub of the upstream testing package because it doesn't compile
+ with tinygo right now.
+*/
@@ -0,0 +1,143 @@
+package testing
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"time"
+)
+
+// InternalFuzzTarget is an internal type but exported because it is
+// cross-package; it is part of the implementation of the "go test" command.
+type InternalFuzzTarget struct {
+	Name string
+	Fn   func(f *F)
+}
+
+// F is a type passed to fuzz tests.
+//
+// Fuzz tests run generated inputs against a provided fuzz target, which can
+// find and report potential bugs in the code being tested.
+//
+// A fuzz test runs the seed corpus by default, which includes entries provided
+// by (*F).Add and entries in the testdata/fuzz/<FuzzTestName> directory. After
+// any necessary setup and calls to (*F).Add, the fuzz test must then call
+// (*F).Fuzz to provide the fuzz target. See the testing package documentation
+// for an example, and see the F.Fuzz and F.Add method documentation for
+// details.
+//
+// *F methods can only be called before (*F).Fuzz. Once the test is
+// executing the fuzz target, only (*T) methods can be used. The only *F methods
+// that are allowed in the (*F).Fuzz function are (*F).Failed and (*F).Name.
+type F struct {
+	common
+	fuzzContext *fuzzContext
+	testContext *testContext
+
+	// inFuzzFn is true when the fuzz function is running. Most F methods cannot
+	// be called when inFuzzFn is true.
+	inFuzzFn bool
+
+	// corpus is a set of seed corpus entries, added with F.Add and loaded
+	// from testdata.
+	corpus []corpusEntry
+
+	result     fuzzResult
+	fuzzCalled bool
+}
+
+// corpusEntry is an alias to the same type as internal/fuzz.CorpusEntry.
+// We use a type alias because we don't want to export this type, and we can't
+// import internal/fuzz from testing.
+type corpusEntry = struct {
+	Parent     string
+	Path       string
+	Data       []byte
+	Values     []interface{}
+	Generation int
+	IsSeed     bool
+}
+
+// Add will add the arguments to the seed corpus for the fuzz test. This will be
+// a no-op if called after or within the fuzz target, and args must match the
+// arguments for the fuzz target.
+func (f *F) Add(args ...interface{}) {
+	var values []interface{}
+	for i := range args {
+		if t := reflect.TypeOf(args[i]); !supportedTypes[t] {
+			panic(fmt.Sprintf("testing: unsupported type to Add %v", t))
+		}
+		values = append(values, args[i])
+	}
+	f.corpus = append(f.corpus, corpusEntry{Values: values, IsSeed: true, Path: fmt.Sprintf("seed#%d", len(f.corpus))})
+}
+
+// supportedTypes represents all of the supported types which can be fuzzed.
+var supportedTypes = map[reflect.Type]bool{
+	reflect.TypeOf(([]byte)("")):  true,
+	reflect.TypeOf((string)("")):  true,
+	reflect.TypeOf((bool)(false)): true,
+	reflect.TypeOf((byte)(0)):     true,
+	reflect.TypeOf((rune)(0)):     true,
+	reflect.TypeOf((float32)(0)):  true,
+	reflect.TypeOf((float64)(0)):  true,
+	reflect.TypeOf((int)(0)):      true,
+	reflect.TypeOf((int8)(0)):     true,
+	reflect.TypeOf((int16)(0)):    true,
+	reflect.TypeOf((int32)(0)):    true,
+	reflect.TypeOf((int64)(0)):    true,
+	reflect.TypeOf((uint)(0)):     true,
+	reflect.TypeOf((uint8)(0)):    true,
+	reflect.TypeOf((uint16)(0)):   true,
+	reflect.TypeOf((uint32)(0)):   true,
+	reflect.TypeOf((uint64)(0)):   true,
+}
+
+// Fuzz runs the fuzz function, ff, for fuzz testing. If ff fails for a set of
+// arguments, those arguments will be added to the seed corpus.
+//
+// ff must be a function with no return value whose first argument is *T and
+// whose remaining arguments are the types to be fuzzed.
+// For example:
+//
+//	f.Fuzz(func(t *testing.T, b []byte, i int) { ... })
+//
+// The following types are allowed: []byte, string, bool, byte, rune, float32,
+// float64, int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64.
+// More types may be supported in the future.
+//
+// ff must not call any *F methods, e.g. (*F).Log, (*F).Error, (*F).Skip. Use
+// the corresponding *T method instead. The only *F methods that are allowed in
+// the (*F).Fuzz function are (*F).Failed and (*F).Name.
+//
+// This function should be fast and deterministic, and its behavior should not
+// depend on shared state. No mutatable input arguments, or pointers to them,
+// should be retained between executions of the fuzz function, as the memory
+// backing them may be mutated during a subsequent invocation. ff must not
+// modify the underlying data of the arguments provided by the fuzzing engine.
+//
+// When fuzzing, F.Fuzz does not return until a problem is found, time runs out
+// (set with -fuzztime), or the test process is interrupted by a signal. F.Fuzz
+// should be called exactly once, unless F.Skip or F.Fail is called beforehand.
+func (f *F) Fuzz(ff interface{}) {
+	f.failed = true
+	f.result.N = 0
+	f.result.T = 0
+	f.result.Error = errors.New("operation not implemented")
+	return
+}
+
+// fuzzContext holds fields common to all fuzz tests.
+type fuzzContext struct {
+	deps testDeps
+	mode fuzzMode
+}
+
+type fuzzMode uint8
+
+// fuzzResult contains the results of a fuzz run.
+type fuzzResult struct {
+	N     int           // The number of iterations.
+	T     time.Duration // The total time taken.
+	Error error         // Error is the error from the failing input
+}
@@ -0,0 +1,9 @@
+// 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.
+//
+//go:build baremetal
+
+package testing
+
+const isBaremetal = true
@@ -0,0 +1,9 @@
+// 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.
+//
+//go:build !baremetal
+
+package testing
+
+const isBaremetal = false
@@ -0,0 +1,323 @@
+// Copyright 2015 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 testing
+
+import (
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+	"sync"
+)
+
+// matcher sanitizes, uniques, and filters names of subtests and subbenchmarks.
+type matcher struct {
+	filter    filterMatch
+	skip      filterMatch
+	matchFunc func(pat, str string) (bool, error)
+
+	mu sync.Mutex
+
+	// subNames is used to deduplicate subtest names.
+	// Each key is the subtest name joined to the deduplicated name of the parent test.
+	// Each value is the count of the number of occurrences of the given subtest name
+	// already seen.
+	subNames map[string]int32
+}
+
+type filterMatch interface {
+	// matches checks the name against the receiver's pattern strings using the
+	// given match function.
+	matches(name []string, matchString func(pat, str string) (bool, error)) (ok, partial bool)
+
+	// verify checks that the receiver's pattern strings are valid filters by
+	// calling the given match function.
+	verify(name string, matchString func(pat, str string) (bool, error)) error
+}
+
+// simpleMatch matches a test name if all of the pattern strings match in
+// sequence.
+type simpleMatch []string
+
+// alternationMatch matches a test name if one of the alternations match.
+type alternationMatch []filterMatch
+
+// TODO: fix test_main to avoid race and improve caching, also allowing to
+// eliminate this Mutex.
+var matchMutex sync.Mutex
+
+func allMatcher() *matcher {
+	return newMatcher(nil, "", "", "")
+}
+
+func newMatcher(matchString func(pat, str string) (bool, error), patterns, name, skips string) *matcher {
+	if isBaremetal {
+		matchString = fakeMatchString
+	}
+
+	var filter, skip filterMatch
+	if patterns == "" {
+		filter = simpleMatch{} // always partial true
+	} else {
+		filter = splitRegexp(patterns)
+		if err := filter.verify(name, matchString); err != nil {
+			fmt.Fprintf(os.Stderr, "testing: invalid regexp for %s\n", err)
+			os.Exit(1)
+		}
+	}
+	if skips == "" {
+		skip = alternationMatch{} // always false
+	} else {
+		skip = splitRegexp(skips)
+		if err := skip.verify("-test.skip", matchString); err != nil {
+			fmt.Fprintf(os.Stderr, "testing: invalid regexp for %v\n", err)
+			os.Exit(1)
+		}
+	}
+	return &matcher{
+		filter:    filter,
+		skip:      skip,
+		matchFunc: matchString,
+		subNames:  map[string]int32{},
+	}
+}
+
+func (m *matcher) fullName(c *common, subname string) (name string, ok, partial bool) {
+	name = subname
+
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if c != nil && c.level > 0 {
+		name = m.unique(c.name, rewrite(subname))
+	}
+
+	matchMutex.Lock()
+	defer matchMutex.Unlock()
+
+	// We check the full array of paths each time to allow for the case that a pattern contains a '/'.
+	elem := strings.Split(name, "/")
+
+	// filter must match.
+	// accept partial match that may produce full match later.
+	ok, partial = m.filter.matches(elem, m.matchFunc)
+	if !ok {
+		return name, false, false
+	}
+
+	// skip must not match.
+	// ignore partial match so we can get to more precise match later.
+	skip, partialSkip := m.skip.matches(elem, m.matchFunc)
+	if skip && !partialSkip {
+		return name, false, false
+	}
+
+	return name, ok, partial
+}
+
+// clearSubNames clears the matcher's internal state, potentially freeing
+// memory. After this is called, T.Name may return the same strings as it did
+// for earlier subtests.
+func (m *matcher) clearSubNames() {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	for key := range m.subNames {
+		delete(m.subNames, key)
+	}
+}
+
+func (m simpleMatch) matches(name []string, matchString func(pat, str string) (bool, error)) (ok, partial bool) {
+	for i, s := range name {
+		if i >= len(m) {
+			break
+		}
+		if ok, _ := matchString(m[i], s); !ok {
+			return false, false
+		}
+	}
+	return true, len(name) < len(m)
+}
+
+func (m simpleMatch) verify(name string, matchString func(pat, str string) (bool, error)) error {
+	for i, s := range m {
+		m[i] = rewrite(s)
+	}
+	// Verify filters before doing any processing.
+	for i, s := range m {
+		if _, err := matchString(s, "non-empty"); err != nil {
+			return fmt.Errorf("element %d of %s (%q): %s", i, name, s, err)
+		}
+	}
+	return nil
+}
+
+func (m alternationMatch) matches(name []string, matchString func(pat, str string) (bool, error)) (ok, partial bool) {
+	for _, m := range m {
+		if ok, partial = m.matches(name, matchString); ok {
+			return ok, partial
+		}
+	}
+	return false, false
+}
+
+func (m alternationMatch) verify(name string, matchString func(pat, str string) (bool, error)) error {
+	for i, m := range m {
+		if err := m.verify(name, matchString); err != nil {
+			return fmt.Errorf("alternation %d of %s", i, err)
+		}
+	}
+	return nil
+}
+
+func splitRegexp(s string) filterMatch {
+	a := make(simpleMatch, 0, strings.Count(s, "/"))
+	b := make(alternationMatch, 0, strings.Count(s, "|"))
+	cs := 0
+	cp := 0
+	for i := 0; i < len(s); {
+		switch s[i] {
+		case '[':
+			cs++
+		case ']':
+			if cs--; cs < 0 { // An unmatched ']' is legal.
+				cs = 0
+			}
+		case '(':
+			if cs == 0 {
+				cp++
+			}
+		case ')':
+			if cs == 0 {
+				cp--
+			}
+		case '\\':
+			i++
+		case '/':
+			if cs == 0 && cp == 0 {
+				a = append(a, s[:i])
+				s = s[i+1:]
+				i = 0
+				continue
+			}
+		case '|':
+			if cs == 0 && cp == 0 {
+				a = append(a, s[:i])
+				s = s[i+1:]
+				i = 0
+				b = append(b, a)
+				a = make(simpleMatch, 0, len(a))
+				continue
+			}
+		}
+		i++
+	}
+
+	a = append(a, s)
+	if len(b) == 0 {
+		return a
+	}
+	return append(b, a)
+}
+
+// unique creates a unique name for the given parent and subname by affixing it
+// with one or more counts, if necessary.
+func (m *matcher) unique(parent, subname string) string {
+	base := parent + "/" + subname
+
+	for {
+		n := m.subNames[base]
+		if n < 0 {
+			panic("subtest count overflow")
+		}
+		m.subNames[base] = n + 1
+
+		if n == 0 && subname != "" {
+			prefix, nn := parseSubtestNumber(base)
+			if len(prefix) < len(base) && nn < m.subNames[prefix] {
+				// This test is explicitly named like "parent/subname#NN",
+				// and #NN was already used for the NNth occurrence of "parent/subname".
+				// Loop to add a disambiguating suffix.
+				continue
+			}
+			return base
+		}
+
+		name := fmt.Sprintf("%s#%02d", base, n)
+		if m.subNames[name] != 0 {
+			// This is the nth occurrence of base, but the name "parent/subname#NN"
+			// collides with the first occurrence of a subtest *explicitly* named
+			// "parent/subname#NN". Try the next number.
+			continue
+		}
+
+		return name
+	}
+}
+
+// parseSubtestNumber splits a subtest name into a "#%02d"-formatted int32
+// suffix (if present), and a prefix preceding that suffix (always).
+func parseSubtestNumber(s string) (prefix string, nn int32) {
+	i := strings.LastIndex(s, "#")
+	if i < 0 {
+		return s, 0
+	}
+
+	prefix, suffix := s[:i], s[i+1:]
+	if len(suffix) < 2 || (len(suffix) > 2 && suffix[0] == '0') {
+		// Even if suffix is numeric, it is not a possible output of a "%02" format
+		// string: it has either too few digits or too many leading zeroes.
+		return s, 0
+	}
+	if suffix == "00" {
+		if !strings.HasSuffix(prefix, "/") {
+			// We only use "#00" as a suffix for subtests named with the empty
+			// string — it isn't a valid suffix if the subtest name is non-empty.
+			return s, 0
+		}
+	}
+
+	n, err := strconv.ParseInt(suffix, 10, 32)
+	if err != nil || n < 0 {
+		return s, 0
+	}
+	return prefix, int32(n)
+}
+
+// rewrite rewrites a subname to having only printable characters and no white
+// space.
+func rewrite(s string) string {
+	b := []byte{}
+	for _, r := range s {
+		switch {
+		case isSpace(r):
+			b = append(b, '_')
+		case !strconv.IsPrint(r):
+			s := strconv.QuoteRune(r)
+			b = append(b, s[1:len(s)-1]...)
+		default:
+			b = append(b, string(r)...)
+		}
+	}
+	return string(b)
+}
+
+func isSpace(r rune) bool {
+	if r < 0x2000 {
+		switch r {
+		// Note: not the same as Unicode Z class.
+		case '\t', '\n', '\v', '\f', '\r', ' ', 0x85, 0xA0, 0x1680:
+			return true
+		}
+	} else {
+		if r <= 0x200a {
+			return true
+		}
+		switch r {
+		case 0x2028, 0x2029, 0x202f, 0x205f, 0x3000:
+			return true
+		}
+	}
+	return false
+}
@@ -0,0 +1,259 @@
+// Copyright 2015 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 testing
+
+import (
+	"fmt"
+	"reflect"
+	"regexp"
+	"strings"
+	"unicode"
+)
+
+// Verify that our IsSpace agrees with unicode.IsSpace.
+func TestIsSpace(t *T) {
+	n := 0
+	for r := rune(0); r <= unicode.MaxRune; r++ {
+		if isSpace(r) != unicode.IsSpace(r) {
+			t.Errorf("IsSpace(%U)=%t incorrect", r, isSpace(r))
+			n++
+			if n > 10 {
+				return
+			}
+		}
+	}
+}
+
+func TestSplitRegexp(t *T) {
+	res := func(s ...string) filterMatch { return simpleMatch(s) }
+	alt := func(m ...filterMatch) filterMatch { return alternationMatch(m) }
+	testCases := []struct {
+		pattern string
+		result  filterMatch
+	}{
+		// Correct patterns
+		// If a regexp pattern is correct, all split regexps need to be correct
+		// as well.
+		{"", res("")},
+		{"/", res("", "")},
+		{"//", res("", "", "")},
+		{"A", res("A")},
+		{"A/B", res("A", "B")},
+		{"A/B/", res("A", "B", "")},
+		{"/A/B/", res("", "A", "B", "")},
+		{"[A]/(B)", res("[A]", "(B)")},
+		{"[/]/[/]", res("[/]", "[/]")},
+		{"[/]/[:/]", res("[/]", "[:/]")},
+		{"/]", res("", "]")},
+		{"]/", res("]", "")},
+		{"]/[/]", res("]", "[/]")},
+		{`([)/][(])`, res(`([)/][(])`)},
+		{"[(]/[)]", res("[(]", "[)]")},
+
+		{"A/B|C/D", alt(res("A", "B"), res("C", "D"))},
+
+		// Faulty patterns
+		// Errors in original should produce at least one faulty regexp in results.
+		{")/", res(")/")},
+		{")/(/)", res(")/(", ")")},
+		{"a[/)b", res("a[/)b")},
+		{"(/]", res("(/]")},
+		{"(/", res("(/")},
+		{"[/]/[/", res("[/]", "[/")},
+		{`\p{/}`, res(`\p{`, "}")},
+		{`\p/`, res(`\p`, "")},
+		{`[[:/:]]`, res(`[[:/:]]`)},
+	}
+	for _, tc := range testCases {
+		a := splitRegexp(tc.pattern)
+		if !reflect.DeepEqual(a, tc.result) {
+			t.Errorf("splitRegexp(%q) = %#v; want %#v", tc.pattern, a, tc.result)
+		}
+
+		// If there is any error in the pattern, one of the returned subpatterns
+		// needs to have an error as well.
+		if _, err := regexp.Compile(tc.pattern); err != nil {
+			ok := true
+			if err := a.verify("", regexp.MatchString); err != nil {
+				ok = false
+			}
+			if ok {
+				t.Errorf("%s: expected error in any of %q", tc.pattern, a)
+			}
+		}
+	}
+}
+
+func TestMatcher(t *T) {
+	testCases := []struct {
+		pattern     string
+		skip        string
+		parent, sub string
+		ok          bool
+		partial     bool
+	}{
+		// Behavior without subtests.
+		{"", "", "", "TestFoo", true, false},
+		{"TestFoo", "", "", "TestFoo", true, false},
+		{"TestFoo/", "", "", "TestFoo", true, true},
+		{"TestFoo/bar/baz", "", "", "TestFoo", true, true},
+		{"TestFoo", "", "", "TestBar", false, false},
+		{"TestFoo/", "", "", "TestBar", false, false},
+		{"TestFoo/bar/baz", "", "", "TestBar/bar/baz", false, false},
+		{"", "TestBar", "", "TestFoo", true, false},
+		{"", "TestBar", "", "TestBar", false, false},
+
+		// Skipping a non-existent test doesn't change anything.
+		{"", "TestFoo/skipped", "", "TestFoo", true, false},
+		{"TestFoo", "TestFoo/skipped", "", "TestFoo", true, false},
+		{"TestFoo/", "TestFoo/skipped", "", "TestFoo", true, true},
+		{"TestFoo/bar/baz", "TestFoo/skipped", "", "TestFoo", true, true},
+		{"TestFoo", "TestFoo/skipped", "", "TestBar", false, false},
+		{"TestFoo/", "TestFoo/skipped", "", "TestBar", false, false},
+		{"TestFoo/bar/baz", "TestFoo/skipped", "", "TestBar/bar/baz", false, false},
+
+		// with subtests
+		{"", "", "TestFoo", "x", true, false},
+		{"TestFoo", "", "TestFoo", "x", true, false},
+		{"TestFoo/", "", "TestFoo", "x", true, false},
+		{"TestFoo/bar/baz", "", "TestFoo", "bar", true, true},
+
+		{"", "TestFoo/skipped", "TestFoo", "x", true, false},
+		{"TestFoo", "TestFoo/skipped", "TestFoo", "x", true, false},
+		{"TestFoo", "TestFoo/skipped", "TestFoo", "skipped", false, false},
+		{"TestFoo/", "TestFoo/skipped", "TestFoo", "x", true, false},
+		{"TestFoo/bar/baz", "TestFoo/skipped", "TestFoo", "bar", true, true},
+
+		// Subtest with a '/' in its name still allows for copy and pasted names
+		// to match.
+		{"TestFoo/bar/baz", "", "TestFoo", "bar/baz", true, false},
+		{"TestFoo/bar/baz", "TestFoo/bar/baz", "TestFoo", "bar/baz", false, false},
+		{"TestFoo/bar/baz", "TestFoo/bar/baz/skip", "TestFoo", "bar/baz", true, false},
+		{"TestFoo/bar/baz", "", "TestFoo/bar", "baz", true, false},
+		{"TestFoo/bar/baz", "", "TestFoo", "x", false, false},
+		{"TestFoo", "", "TestBar", "x", false, false},
+		{"TestFoo/", "", "TestBar", "x", false, false},
+		{"TestFoo/bar/baz", "", "TestBar", "x/bar/baz", false, false},
+
+		{"A/B|C/D", "", "TestA", "B", true, false},
+		{"A/B|C/D", "", "TestC", "D", true, false},
+		{"A/B|C/D", "", "TestA", "C", false, false},
+
+		// subtests only
+		{"", "", "TestFoo", "x", true, false},
+		{"/", "", "TestFoo", "x", true, false},
+		{"./", "", "TestFoo", "x", true, false},
+		{"./.", "", "TestFoo", "x", true, false},
+		{"/bar/baz", "", "TestFoo", "bar", true, true},
+		{"/bar/baz", "", "TestFoo", "bar/baz", true, false},
+		{"//baz", "", "TestFoo", "bar/baz", true, false},
+		{"//", "", "TestFoo", "bar/baz", true, false},
+		{"/bar/baz", "", "TestFoo/bar", "baz", true, false},
+		{"//foo", "", "TestFoo", "bar/baz", false, false},
+		{"/bar/baz", "", "TestFoo", "x", false, false},
+		{"/bar/baz", "", "TestBar", "x/bar/baz", false, false},
+	}
+
+	for _, tc := range testCases {
+		m := newMatcher(regexp.MatchString, tc.pattern, "-test.run", tc.skip)
+
+		parent := &common{name: tc.parent}
+		if tc.parent != "" {
+			parent.level = 1
+		}
+		if n, ok, partial := m.fullName(parent, tc.sub); ok != tc.ok || partial != tc.partial {
+			t.Errorf("for pattern %q, fullName(parent=%q, sub=%q) = %q, ok %v partial %v; want ok %v partial %v",
+				tc.pattern, tc.parent, tc.sub, n, ok, partial, tc.ok, tc.partial)
+		}
+	}
+}
+
+var namingTestCases = []struct{ name, want string }{
+	// Uniqueness
+	{"", "x/#00"},
+	{"", "x/#01"},
+	{"#0", "x/#0"},      // Doesn't conflict with #00 because the number of digits differs.
+	{"#00", "x/#00#01"}, // Conflicts with implicit #00 (used above), so add a suffix.
+	{"#", "x/#"},
+	{"#", "x/##01"},
+
+	{"t", "x/t"},
+	{"t", "x/t#01"},
+	{"t", "x/t#02"},
+	{"t#00", "x/t#00"}, // Explicit "#00" doesn't conflict with the unsuffixed first subtest.
+
+	{"a#01", "x/a#01"},    // user has subtest with this name.
+	{"a", "x/a"},          // doesn't conflict with this name.
+	{"a", "x/a#02"},       // This string is claimed now, so resume
+	{"a", "x/a#03"},       // with counting.
+	{"a#02", "x/a#02#01"}, // We already used a#02 once, so add a suffix.
+
+	{"b#00", "x/b#00"},
+	{"b", "x/b"}, // Implicit 0 doesn't conflict with explicit "#00".
+	{"b", "x/b#01"},
+	{"b#9223372036854775807", "x/b#9223372036854775807"}, // MaxInt64
+	{"b", "x/b#02"},
+	{"b", "x/b#03"},
+
+	// Sanitizing
+	{"A:1 B:2", "x/A:1_B:2"},
+	{"s\t\r\u00a0", "x/s___"},
+	{"\x01", `x/\x01`},
+	{"\U0010ffff", `x/\U0010ffff`},
+}
+
+func TestNaming(t *T) {
+	m := newMatcher(regexp.MatchString, "", "", "")
+	parent := &common{name: "x", level: 1} // top-level test.
+
+	for i, tc := range namingTestCases {
+		if got, _, _ := m.fullName(parent, tc.name); got != tc.want {
+			t.Errorf("%d:%s: got %q; want %q", i, tc.name, got, tc.want)
+		}
+	}
+}
+
+func FuzzNaming(f *F) {
+	for _, tc := range namingTestCases {
+		f.Add(tc.name)
+	}
+	parent := &common{name: "x", level: 1}
+	var m *matcher
+	var seen map[string]string
+	reset := func() {
+		m = allMatcher()
+		seen = make(map[string]string)
+	}
+	reset()
+
+	f.Fuzz(func(t *T, subname string) {
+		if len(subname) > 10 {
+			// Long names attract the OOM killer.
+			t.Skip()
+		}
+		name := m.unique(parent.name, subname)
+		if !strings.Contains(name, "/"+subname) {
+			t.Errorf("name %q does not contain subname %q", name, subname)
+		}
+		if prev, ok := seen[name]; ok {
+			t.Errorf("name %q generated by both %q and %q", name, prev, subname)
+		}
+		if len(seen) > 1e6 {
+			// Free up memory.
+			reset()
+		}
+		seen[name] = subname
+	})
+}
+
+// GoString returns a string that is more readable than the default, which makes
+// it easier to read test errors.
+func (m alternationMatch) GoString() string {
+	s := make([]string, len(m))
+	for i, m := range m {
+		s[i] = fmt.Sprintf("%#v", m)
+	}
+	return fmt.Sprintf("(%s)", strings.Join(s, " | "))
+}
@@ -0,0 +1,80 @@
+// 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.
+
+package testing
+
+import (
+	"reflect"
+)
+
+func TestCleanup(t *T) {
+	var cleanups []int
+	t.Run("test", func(t *T) {
+		t.Cleanup(func() { cleanups = append(cleanups, 1) })
+		t.Cleanup(func() { cleanups = append(cleanups, 2) })
+	})
+	if got, want := cleanups, []int{2, 1}; !reflect.DeepEqual(got, want) {
+		t.Errorf("unexpected cleanup record; got %v want %v", got, want)
+	}
+}
+
+func TestRunCleanup(t *T) {
+	outerCleanup := 0
+	innerCleanup := 0
+	t.Run("test", func(t *T) {
+		t.Cleanup(func() { outerCleanup++ })
+		t.Run("x", func(t *T) {
+			t.Cleanup(func() { innerCleanup++ })
+		})
+	})
+	if innerCleanup != 1 {
+		t.Errorf("unexpected inner cleanup count; got %d want 1", innerCleanup)
+	}
+	if outerCleanup != 1 {
+		t.Errorf("unexpected outer cleanup count; got %d want 1", outerCleanup) // wrong upstream!
+	}
+}
+
+func TestCleanupParallelSubtests(t *T) {
+	ranCleanup := 0
+	t.Run("test", func(t *T) {
+		t.Cleanup(func() { ranCleanup++ })
+		t.Run("x", func(t *T) {
+			t.Parallel()
+			if ranCleanup > 0 {
+				t.Error("outer cleanup ran before parallel subtest")
+			}
+		})
+	})
+	if ranCleanup != 1 {
+		t.Errorf("unexpected cleanup count; got %d want 1", ranCleanup)
+	}
+}
+
+func TestNestedCleanup(t *T) {
+	ranCleanup := 0
+	t.Run("test", func(t *T) {
+		t.Cleanup(func() {
+			if ranCleanup != 2 {
+				t.Errorf("unexpected cleanup count in first cleanup: got %d want 2", ranCleanup)
+			}
+			ranCleanup++
+		})
+		t.Cleanup(func() {
+			if ranCleanup != 0 {
+				t.Errorf("unexpected cleanup count in second cleanup: got %d want 0", ranCleanup)
+			}
+			ranCleanup++
+			t.Cleanup(func() {
+				if ranCleanup != 1 {
+					t.Errorf("unexpected cleanup count in nested cleanup: got %d want 1", ranCleanup)
+				}
+				ranCleanup++
+			})
+		})
+	})
+	if ranCleanup != 3 {
+		t.Errorf("unexpected cleanup count: got %d want 3", ranCleanup)
+	}
+}
@@ -0,0 +1,709 @@
+// 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.
+//
+// This file has been modified for use by the TinyGo compiler.
+// src: https://github.com/golang/go/blob/61bb56ad/src/testing/testing.go
+
+// Package testing provides support for automated testing of Go packages.
+package testing
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"io/fs"
+	"math/rand"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"time"
+	"unicode"
+	"unicode/utf8"
+)
+
+// Testing flags.
+var (
+	flagVerbose    bool
+	flagShort      bool
+	flagRunRegexp  string
+	flagSkipRegexp string
+	flagShuffle    string
+	flagCount      int
+)
+
+var initRan bool
+
+// Init registers testing flags. It has no effect if it has already run.
+func Init() {
+	if initRan {
+		return
+	}
+	initRan = true
+
+	flag.BoolVar(&flagVerbose, "test.v", false, "verbose: print additional output")
+	flag.BoolVar(&flagShort, "test.short", false, "short: run smaller test suite to save time")
+	flag.StringVar(&flagRunRegexp, "test.run", "", "run: regexp of tests to run")
+	flag.StringVar(&flagSkipRegexp, "test.skip", "", "skip: regexp of tests to run")
+	flag.StringVar(&flagShuffle, "test.shuffle", "off", "shuffle: off, on, <numeric-seed>")
+
+	flag.IntVar(&flagCount, "test.count", 1, "run each test or benchmark `count` times")
+
+	initBenchmarkFlags()
+}
+
+// common holds the elements common between T and B and
+// captures common methods such as Errorf.
+type common struct {
+	output   *logger
+	indent   string
+	ran      bool     // Test or benchmark (or one of its subtests) was executed.
+	failed   bool     // Test or benchmark has failed.
+	skipped  bool     // Test of benchmark has been skipped.
+	cleanups []func() // optional functions to be called at the end of the test
+	finished bool     // Test function has completed.
+
+	hasSub bool // TODO: should be atomic
+
+	parent   *common
+	level    int       // Nesting depth of test or benchmark.
+	name     string    // Name of test or benchmark.
+	start    time.Time // Time test or benchmark started
+	duration time.Duration
+
+	tempDir    string
+	tempDirErr error
+	tempDirSeq int32
+
+	ctx       context.Context
+	cancelCtx context.CancelFunc
+}
+
+type logger struct {
+	logToStdout bool
+	b           bytes.Buffer
+}
+
+func (l *logger) Write(p []byte) (int, error) {
+	if l.logToStdout {
+		return os.Stdout.Write(p)
+	}
+	return l.b.Write(p)
+}
+
+func (l *logger) WriteTo(w io.Writer) (int64, error) {
+	if l.logToStdout {
+		// We've already been logging to stdout; nothing to do.
+		return 0, nil
+	}
+	return l.b.WriteTo(w)
+
+}
+
+func (l *logger) Len() int {
+	return l.b.Len()
+}
+
+// Short reports whether the -test.short flag is set.
+func Short() bool {
+	return flagShort
+}
+
+// CoverMode reports what the test coverage mode is set to.
+//
+// Test coverage is not supported; this returns the empty string.
+func CoverMode() string {
+	return ""
+}
+
+// Verbose reports whether the -test.v flag is set.
+func Verbose() bool {
+	return flagVerbose
+}
+
+// String constant that is being set when running a test.
+var testBinary string
+
+// Testing returns whether the program was compiled as a test, using "tinygo
+// test". It returns false when built using "tinygo build", "tinygo flash", etc.
+func Testing() bool {
+	return testBinary == "1"
+}
+
+// flushToParent writes c.output to the parent after first writing the header
+// with the given format and arguments.
+func (c *common) flushToParent(testName, format string, args ...interface{}) {
+	if c.parent == nil {
+		// The fake top-level test doesn't want a FAIL or PASS banner.
+		// Not quite sure how this works upstream.
+		c.output.WriteTo(os.Stdout)
+	} else {
+		fmt.Fprintf(c.parent.output, format, args...)
+		c.output.WriteTo(c.parent.output)
+	}
+}
+
+// fmtDuration returns a string representing d in the form "87.00s".
+func fmtDuration(d time.Duration) string {
+	return fmt.Sprintf("%.2fs", d.Seconds())
+}
+
+// TB is the interface common to T and B.
+type TB interface {
+	Cleanup(func())
+	Context() context.Context
+	Error(args ...interface{})
+	Errorf(format string, args ...interface{})
+	Fail()
+	FailNow()
+	Failed() bool
+	Fatal(args ...interface{})
+	Fatalf(format string, args ...interface{})
+	Helper()
+	Log(args ...interface{})
+	Logf(format string, args ...interface{})
+	Name() string
+	Setenv(key, value string)
+	Skip(args ...interface{})
+	SkipNow()
+	Skipf(format string, args ...interface{})
+	Skipped() bool
+	TempDir() string
+}
+
+var _ TB = (*T)(nil)
+var _ TB = (*B)(nil)
+
+// T is a type passed to Test functions to manage test state and support formatted test logs.
+// Logs are accumulated during execution and dumped to standard output when done.
+type T struct {
+	common
+	context *testContext // For running tests and subtests.
+}
+
+// Name returns the name of the running test or benchmark.
+func (c *common) Name() string {
+	return c.name
+}
+
+func (c *common) setRan() {
+	if c.parent != nil {
+		c.parent.setRan()
+	}
+	c.ran = true
+}
+
+// Fail marks the function as having failed but continues execution.
+func (c *common) Fail() {
+	c.failed = true
+}
+
+// Failed reports whether the function has failed.
+func (c *common) Failed() bool {
+	failed := c.failed
+	return failed
+}
+
+// FailNow marks the function as having failed and stops its execution
+// by calling runtime.Goexit (which then runs all deferred calls in the
+// current goroutine).
+func (c *common) FailNow() {
+	c.Fail()
+
+	c.finished = true
+	c.Error("FailNow is incomplete, requires runtime.Goexit()")
+}
+
+// log generates the output.
+func (c *common) log(s string) {
+	// This doesn't print the same as in upstream go, but works for now.
+	if len(s) != 0 && s[len(s)-1] == '\n' {
+		s = s[:len(s)-1]
+	}
+	lines := strings.Split(s, "\n")
+	// First line.
+	fmt.Fprintf(c.output, "%s    %s\n", c.indent, lines[0])
+	// More lines.
+	for _, line := range lines[1:] {
+		fmt.Fprintf(c.output, "%s        %s\n", c.indent, line)
+	}
+}
+
+// Log formats its arguments using default formatting, analogous to Println,
+// and records the text in the error log. For tests, the text will be printed only if
+// the test fails or the -test.v flag is set. For benchmarks, the text is always
+// printed to avoid having performance depend on the value of the -test.v flag.
+func (c *common) Log(args ...interface{}) { c.log(fmt.Sprintln(args...)) }
+
+// Logf formats its arguments according to the format, analogous to Printf, and
+// records the text in the error log. A final newline is added if not provided. For
+// tests, the text will be printed only if the test fails or the -test.v flag is
+// set. For benchmarks, the text is always printed to avoid having performance
+// depend on the value of the -test.v flag.
+func (c *common) Logf(format string, args ...interface{}) { c.log(fmt.Sprintf(format, args...)) }
+
+// Error is equivalent to Log followed by Fail.
+func (c *common) Error(args ...interface{}) {
+	c.log(fmt.Sprintln(args...))
+	c.Fail()
+}
+
+// Errorf is equivalent to Logf followed by Fail.
+func (c *common) Errorf(format string, args ...interface{}) {
+	c.log(fmt.Sprintf(format, args...))
+	c.Fail()
+}
+
+// Fatal is equivalent to Log followed by FailNow.
+func (c *common) Fatal(args ...interface{}) {
+	c.log(fmt.Sprintln(args...))
+	c.FailNow()
+}
+
+// Fatalf is equivalent to Logf followed by FailNow.
+func (c *common) Fatalf(format string, args ...interface{}) {
+	c.log(fmt.Sprintf(format, args...))
+	c.FailNow()
+}
+
+// Skip is equivalent to Log followed by SkipNow.
+func (c *common) Skip(args ...interface{}) {
+	c.log(fmt.Sprintln(args...))
+	c.SkipNow()
+}
+
+// Skipf is equivalent to Logf followed by SkipNow.
+func (c *common) Skipf(format string, args ...interface{}) {
+	c.log(fmt.Sprintf(format, args...))
+	c.SkipNow()
+}
+
+// SkipNow marks the test as having been skipped and stops its execution
+// by calling runtime.Goexit.
+func (c *common) SkipNow() {
+	c.skip()
+	c.finished = true
+	c.Error("SkipNow is incomplete, requires runtime.Goexit()")
+}
+
+func (c *common) skip() {
+	c.skipped = true
+}
+
+// Skipped reports whether the test was skipped.
+func (c *common) Skipped() bool {
+	return c.skipped
+}
+
+// Helper is not implemented, it is only provided for compatibility.
+func (c *common) Helper() {
+	// Unimplemented.
+}
+
+// Cleanup registers a function to be called when the test (or subtest) and all its
+// subtests complete. Cleanup functions will be called in last added,
+// first called order.
+func (c *common) Cleanup(f func()) {
+	c.cleanups = append(c.cleanups, f)
+}
+
+// Context returns a context that is canceled just before
+// Cleanup-registered functions are called.
+//
+// Cleanup functions can wait for any resources
+// that shut down on [context.Context.Done] before the test or benchmark completes.
+func (c *common) Context() context.Context {
+	return c.ctx
+}
+
+// TempDir returns a temporary directory for the test to use.
+// The directory is automatically removed by Cleanup when the test and
+// all its subtests complete.
+// Each subsequent call to t.TempDir returns a unique directory;
+// if the directory creation fails, TempDir terminates the test by calling Fatal.
+func (c *common) TempDir() string {
+	// Use a single parent directory for all the temporary directories
+	// created by a test, each numbered sequentially.
+	var nonExistent bool
+	if c.tempDir == "" { // Usually the case with js/wasm
+		nonExistent = true
+	} else {
+		_, err := os.Stat(c.tempDir)
+		nonExistent = errors.Is(err, fs.ErrNotExist)
+		if err != nil && !nonExistent {
+			c.Fatalf("TempDir: %v", err)
+		}
+	}
+
+	if nonExistent {
+		c.Helper()
+
+		// Drop unusual characters (such as path separators or
+		// characters interacting with globs) from the directory name to
+		// avoid surprising os.MkdirTemp behavior.
+		mapper := func(r rune) rune {
+			if r < utf8.RuneSelf {
+				const allowed = "!#$%&()+,-.=@^_{}~ "
+				if '0' <= r && r <= '9' ||
+					'a' <= r && r <= 'z' ||
+					'A' <= r && r <= 'Z' {
+					return r
+				}
+				if strings.ContainsRune(allowed, r) {
+					return r
+				}
+			} else if unicode.IsLetter(r) || unicode.IsNumber(r) {
+				return r
+			}
+			return -1
+		}
+		pattern := strings.Map(mapper, c.Name())
+		c.tempDir, c.tempDirErr = os.MkdirTemp("", pattern)
+		if c.tempDirErr == nil {
+			c.Cleanup(func() {
+				if err := os.RemoveAll(c.tempDir); err != nil {
+					c.Errorf("TempDir RemoveAll cleanup: %v", err)
+				}
+			})
+		}
+	}
+
+	if c.tempDirErr != nil {
+		c.Fatalf("TempDir: %v", c.tempDirErr)
+	}
+	seq := c.tempDirSeq
+	c.tempDirSeq++
+	dir := fmt.Sprintf("%s%c%03d", c.tempDir, os.PathSeparator, seq)
+	if err := os.Mkdir(dir, 0777); err != nil {
+		c.Fatalf("TempDir: %v", err)
+	}
+	return dir
+}
+
+// Setenv calls os.Setenv(key, value) and uses Cleanup to
+// restore the environment variable to its original value
+// after the test.
+func (c *common) Setenv(key, value string) {
+	prevValue, ok := os.LookupEnv(key)
+
+	if err := os.Setenv(key, value); err != nil {
+		c.Fatalf("cannot set environment variable: %v", err)
+	}
+
+	if ok {
+		c.Cleanup(func() {
+			os.Setenv(key, prevValue)
+		})
+	} else {
+		c.Cleanup(func() {
+			os.Unsetenv(key)
+		})
+	}
+}
+
+// Chdir calls os.Chdir(dir) and uses Cleanup to restore the current
+// working directory to its original value after the test. On Unix, it
+// also sets PWD environment variable for the duration of the test.
+//
+// Because Chdir affects the whole process, it cannot be used
+// in parallel tests or tests with parallel ancestors.
+func (c *common) Chdir(dir string) {
+	// Note: function copied from the Go 1.24.0 source tree.
+
+	oldwd, err := os.Open(".")
+	if err != nil {
+		c.Fatal(err)
+	}
+	if err := os.Chdir(dir); err != nil {
+		c.Fatal(err)
+	}
+	// On POSIX platforms, PWD represents “an absolute pathname of the
+	// current working directory.” Since we are changing the working
+	// directory, we should also set or update PWD to reflect that.
+	switch runtime.GOOS {
+	case "windows", "plan9":
+		// Windows and Plan 9 do not use the PWD variable.
+	default:
+		if !filepath.IsAbs(dir) {
+			dir, err = os.Getwd()
+			if err != nil {
+				c.Fatal(err)
+			}
+		}
+		c.Setenv("PWD", dir)
+	}
+	c.Cleanup(func() {
+		err := oldwd.Chdir()
+		oldwd.Close()
+		if err != nil {
+			// It's not safe to continue with tests if we can't
+			// get back to the original working directory. Since
+			// we are holding a dirfd, this is highly unlikely.
+			panic("testing.Chdir: " + err.Error())
+		}
+	})
+}
+
+// runCleanup is called at the end of the test.
+func (c *common) runCleanup() {
+	for {
+		var cleanup func()
+		if len(c.cleanups) > 0 {
+			last := len(c.cleanups) - 1
+			cleanup = c.cleanups[last]
+			c.cleanups = c.cleanups[:last]
+		}
+		if cleanup == nil {
+			return
+		}
+		if c.cancelCtx != nil {
+			c.cancelCtx()
+		}
+		cleanup()
+	}
+}
+
+// Parallel is not implemented, it is only provided for compatibility.
+func (t *T) Parallel() {
+	// Unimplemented.
+}
+
+// InternalTest is a reference to a test that should be called during a test suite run.
+type InternalTest struct {
+	Name string
+	F    func(*T)
+}
+
+func tRunner(t *T, fn func(t *T)) {
+	defer func() {
+		t.runCleanup()
+	}()
+
+	// Run the test.
+	t.start = time.Now()
+	fn(t)
+	t.duration += time.Since(t.start) // TODO: capture cleanup time, too.
+
+	t.report() // Report after all subtests have finished.
+	if t.parent != nil && !t.hasSub {
+		t.setRan()
+	}
+}
+
+// Run runs f as a subtest of t called name. It waits until the subtest is finished
+// and returns whether the subtest succeeded.
+func (t *T) Run(name string, f func(t *T)) bool {
+	t.hasSub = true
+	testName, ok, _ := t.context.match.fullName(&t.common, name)
+	if !ok {
+		return true
+	}
+
+	// Create a subtest.
+	ctx, cancelCtx := context.WithCancel(context.Background())
+	sub := T{
+		common: common{
+			output:    &logger{logToStdout: flagVerbose},
+			name:      testName,
+			parent:    &t.common,
+			level:     t.level + 1,
+			ctx:       ctx,
+			cancelCtx: cancelCtx,
+		},
+		context: t.context,
+	}
+	if t.level > 0 {
+		sub.indent = sub.indent + "    "
+	}
+	if flagVerbose {
+		fmt.Fprintf(t.output, "=== RUN   %s\n", sub.name)
+	}
+
+	tRunner(&sub, f)
+	return !sub.failed
+}
+
+// Deadline reports the time at which the test binary will have
+// exceeded the timeout specified by the -timeout flag.
+//
+// The ok result is false if the -timeout flag indicates “no timeout” (0).
+// For now tinygo always return 0, false.
+//
+// Not Implemented.
+func (t *T) Deadline() (deadline time.Time, ok bool) {
+	deadline = t.context.deadline
+	return deadline, !deadline.IsZero()
+}
+
+// testContext holds all fields that are common to all tests. This includes
+// synchronization primitives to run at most *parallel tests.
+type testContext struct {
+	match    *matcher
+	deadline time.Time
+}
+
+func newTestContext(m *matcher) *testContext {
+	return &testContext{
+		match: m,
+	}
+}
+
+// M is a test suite.
+type M struct {
+	// tests is a list of the test names to execute
+	Tests      []InternalTest
+	Benchmarks []InternalBenchmark
+
+	deps testDeps
+
+	// value to pass to os.Exit, the outer test func main
+	// harness calls os.Exit with this code. See #34129.
+	exitCode int
+}
+
+type testDeps interface {
+	MatchString(pat, str string) (bool, error)
+}
+
+func (m *M) shuffle() error {
+	var n int64
+
+	if flagShuffle == "on" {
+		n = time.Now().UnixNano()
+	} else {
+		var err error
+		n, err = strconv.ParseInt(flagShuffle, 10, 64)
+		if err != nil {
+			m.exitCode = 2
+			return fmt.Errorf(`testing: -shuffle should be "off", "on", or a valid integer: %v`, err)
+		}
+	}
+
+	fmt.Println("-test.shuffle", n)
+	rng := rand.New(rand.NewSource(n))
+	rng.Shuffle(len(m.Tests), func(i, j int) { m.Tests[i], m.Tests[j] = m.Tests[j], m.Tests[i] })
+	rng.Shuffle(len(m.Benchmarks), func(i, j int) { m.Benchmarks[i], m.Benchmarks[j] = m.Benchmarks[j], m.Benchmarks[i] })
+	return nil
+}
+
+// Run runs the tests. It returns an exit code to pass to os.Exit.
+func (m *M) Run() (code int) {
+	defer func() {
+		code = m.exitCode
+	}()
+
+	if !flag.Parsed() {
+		flag.Parse()
+	}
+
+	if flagShuffle != "off" {
+		if err := m.shuffle(); err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			return
+		}
+	}
+
+	testRan, testOk := runTests(m.deps.MatchString, m.Tests)
+	if !testRan && *matchBenchmarks == "" {
+		fmt.Fprintln(os.Stderr, "testing: warning: no tests to run")
+	}
+	if !testOk || !runBenchmarks(m.deps.MatchString, m.Benchmarks) {
+		fmt.Println("FAIL")
+		m.exitCode = 1
+	} else {
+		fmt.Println("PASS")
+		m.exitCode = 0
+	}
+	return
+}
+
+func runTests(matchString func(pat, str string) (bool, error), tests []InternalTest) (ran, ok bool) {
+	ok = true
+
+	ctx := newTestContext(newMatcher(matchString, flagRunRegexp, "-test.run", flagSkipRegexp))
+	runCtx, cancelCtx := context.WithCancel(context.Background())
+	t := &T{
+		common: common{
+			output:    &logger{logToStdout: flagVerbose},
+			ctx:       runCtx,
+			cancelCtx: cancelCtx,
+		},
+		context: ctx,
+	}
+
+	for i := 0; i < flagCount; i++ {
+		tRunner(t, func(t *T) {
+			for _, test := range tests {
+				t.Run(test.Name, test.F)
+				ok = ok && !t.Failed()
+			}
+		})
+	}
+
+	return t.ran, ok
+}
+
+func (t *T) report() {
+	dstr := fmtDuration(t.duration)
+	format := t.indent + "--- %s: %s (%s)\n"
+	if t.Failed() {
+		if t.parent != nil {
+			t.parent.failed = true
+		}
+		t.flushToParent(t.name, format, "FAIL", t.name, dstr)
+	} else if flagVerbose {
+		if t.Skipped() {
+			t.flushToParent(t.name, format, "SKIP", t.name, dstr)
+		} else {
+			t.flushToParent(t.name, format, "PASS", t.name, dstr)
+		}
+	}
+}
+
+// AllocsPerRun returns the average number of allocations during calls to f.
+// Although the return value has type float64, it will always be an integral
+// value.
+//
+// Not implemented.
+func AllocsPerRun(runs int, f func()) (avg float64) {
+	f()
+	for i := 0; i < runs; i++ {
+		f()
+	}
+	return 0
+}
+
+type InternalExample struct {
+	Name      string
+	F         func()
+	Output    string
+	Unordered bool
+}
+
+// MainStart is meant for use by tests generated by 'go test'.
+// It is not meant to be called directly and is not subject to the Go 1 compatibility document.
+// It may change signature from release to release.
+func MainStart(deps interface{}, tests []InternalTest, benchmarks []InternalBenchmark, fuzzTargets []InternalFuzzTarget, examples []InternalExample) *M {
+	Init()
+	return &M{
+		Tests:      tests,
+		Benchmarks: benchmarks,
+		deps:       deps.(testDeps),
+	}
+}
+
+// A fake regexp matcher.
+// Inflexible, but saves 50KB of flash and 50KB of RAM per -size full,
+// and lets tests pass on cortex-m.
+func fakeMatchString(pat, str string) (bool, error) {
+	if pat == ".*" {
+		return true, nil
+	}
+	matched := strings.Contains(str, pat)
+	return matched, nil
+}
@@ -0,0 +1,204 @@
+//go:build !windows
+
+// TODO: implement readdir for windows, then enable this file
+
+// Copyright 2014 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 testing_test
+
+import (
+	"errors"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"runtime"
+	"testing"
+)
+
+// This is exactly what a test would do without a TestMain.
+// It's here only so that there is at least one package in the
+// standard library with a TestMain, so that code is executed.
+
+func TestMain(m *testing.M) {
+	os.Exit(m.Run())
+}
+
+func TestTempDirInCleanup(t *testing.T) {
+	if runtime.GOOS == "wasip1" || runtime.GOOS == "wasip2" {
+		t.Log("Skipping.  TODO: implement RemoveAll for wasi")
+		return
+	}
+
+	var dir string
+
+	t.Run("test", func(t *testing.T) {
+		t.Cleanup(func() {
+			dir = t.TempDir()
+		})
+		_ = t.TempDir()
+	})
+
+	fi, err := os.Stat(dir)
+	if fi != nil {
+		t.Fatalf("Directory %q from user Cleanup still exists", dir)
+	}
+	if !errors.Is(err, fs.ErrNotExist) {
+		t.Fatalf("Unexpected error: %v", err)
+	}
+}
+
+func TestTempDirInBenchmark(t *testing.T) {
+	testing.Benchmark(func(b *testing.B) {
+		if !b.Run("test", func(b *testing.B) {
+			// Add a loop so that the test won't fail. See issue 38677.
+			for i := 0; i < b.N; i++ {
+				_ = b.TempDir()
+			}
+		}) {
+			t.Fatal("Sub test failure in a benchmark")
+		}
+	})
+}
+
+func TestTempDir(t *testing.T) {
+	if runtime.GOOS == "wasip1" || runtime.GOOS == "wasip2" {
+		t.Log("Skipping.  TODO: implement RemoveAll for wasi")
+		return
+	}
+
+	testTempDir(t)
+	t.Run("InSubtest", testTempDir)
+	t.Run("test/subtest", testTempDir)
+	t.Run("test\\subtest", testTempDir)
+	t.Run("test:subtest", testTempDir)
+	t.Run("test/..", testTempDir)
+	t.Run("../test", testTempDir)
+	t.Run("test[]", testTempDir)
+	t.Run("test*", testTempDir)
+	t.Run("äöüéè", testTempDir)
+}
+
+func testTempDir(t *testing.T) {
+	dirCh := make(chan string, 1)
+	t.Cleanup(func() {
+		// Verify directory has been removed.
+		select {
+		case dir := <-dirCh:
+			fi, err := os.Stat(dir)
+			if errors.Is(err, fs.ErrNotExist) {
+				// All good
+				return
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			t.Errorf("directory %q still exists: %v, isDir=%v", dir, fi, fi.IsDir())
+		default:
+			if !t.Failed() {
+				t.Fatal("never received dir channel")
+			}
+		}
+	})
+
+	dir := t.TempDir()
+	if dir == "" {
+		t.Fatal("expected dir")
+	}
+	dir2 := t.TempDir()
+	if dir == dir2 {
+		t.Fatal("subsequent calls to TempDir returned the same directory")
+	}
+	if filepath.Dir(dir) != filepath.Dir(dir2) {
+		t.Fatalf("calls to TempDir do not share a parent; got %q, %q", dir, dir2)
+	}
+	dirCh <- dir
+	fi, err := os.Stat(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !fi.IsDir() {
+		t.Errorf("dir %q is not a dir", dir)
+	}
+	files, err := os.ReadDir(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(files) > 0 {
+		t.Errorf("unexpected %d files in TempDir: %v", len(files), files)
+	}
+
+	glob := filepath.Join(dir, "*.txt")
+	if _, err := filepath.Glob(glob); err != nil {
+		t.Error(err)
+	}
+
+	err = os.Remove(dir)
+	if err != nil {
+		t.Errorf("unexpected files in TempDir")
+	}
+}
+
+func TestSetenv(t *testing.T) {
+	tests := []struct {
+		name               string
+		key                string
+		initialValueExists bool
+		initialValue       string
+		newValue           string
+	}{
+		{
+			name:               "initial value exists",
+			key:                "GO_TEST_KEY_1",
+			initialValueExists: true,
+			initialValue:       "111",
+			newValue:           "222",
+		},
+		{
+			name:               "initial value exists but empty",
+			key:                "GO_TEST_KEY_2",
+			initialValueExists: true,
+			initialValue:       "",
+			newValue:           "222",
+		},
+		{
+			name:               "initial value is not exists",
+			key:                "GO_TEST_KEY_3",
+			initialValueExists: false,
+			initialValue:       "",
+			newValue:           "222",
+		},
+	}
+
+	for _, test := range tests {
+		if test.initialValueExists {
+			if err := os.Setenv(test.key, test.initialValue); err != nil {
+				t.Fatalf("unable to set env: got %v", err)
+			}
+		} else {
+			os.Unsetenv(test.key)
+		}
+
+		t.Run(test.name, func(t *testing.T) {
+			t.Setenv(test.key, test.newValue)
+			if os.Getenv(test.key) != test.newValue {
+				t.Fatalf("unexpected value after t.Setenv: got %s, want %s", os.Getenv(test.key), test.newValue)
+			}
+		})
+
+		got, exists := os.LookupEnv(test.key)
+		if got != test.initialValue {
+			t.Fatalf("unexpected value after t.Setenv cleanup: got %s, want %s", got, test.initialValue)
+		}
+		if exists != test.initialValueExists {
+			t.Fatalf("unexpected value after t.Setenv cleanup: got %t, want %t", exists, test.initialValueExists)
+		}
+	}
+}
+
+func TestTesting(t *testing.T) {
+	if !testing.Testing() {
+		t.Error("Expected testing.Testing() to return true while in a test")
+	}
+}
@@ -0,0 +1,11 @@
+{
+    "inherits": [
+        "rp2350b"
+    ],
+    "build-tags": ["pico2_ice"],
+    "serial-port": ["2e8a:000A"],
+    "default-stack-size": 8192,
+    "ldflags": [
+        "--defsym=__flash_size=4M"
+    ]
+}
Author	SHA1	Message	Date
Ayke van Laethem	ec9e041a40	ci: use native arm64 builder for arm64 binaries	2025-11-09 09:41:06 +01:00
deadprogram	bf613175e7	ci: update GH actions builds to use Go 1.25.4 Signed-off-by: deadprogram <ron@hybridgroup.com>	2025-11-07 10:04:33 +01:00
sivchari	4d62cca267	feature: Add flag to ignore go compatibility matrix (#5078 ) * add go-compatibility feature Signed-off-by: sivchari <shibuuuu5@gmail.com> * rename env Signed-off-by: sivchari <shibuuuu5@gmail.com> * fix description Signed-off-by: sivchari <shibuuuu5@gmail.com> --------- Signed-off-by: sivchari <shibuuuu5@gmail.com>	2025-11-06 21:28:06 +01:00
deadprogram	a63aa143bb	build: use task scheduler on macOS builds to avoid test race condition lockups. Fixes #4995 Signed-off-by: deadprogram <ron@hybridgroup.com>	2025-11-06 19:19:20 +01:00
Ben Krieger	ed0fb774b9	Add testing.T.Context() and testing.B.Context()	2025-11-05 10:33:15 +01:00
Damian Gryski	9be956f4bc	src/syscall: update src buffer after write Fixes #5012	2025-10-28 12:43:23 -07:00
Ayke van Laethem	48d741f68a	compiler: emit an error when the actual arch doesn't match GOARCH See: https://github.com/tinygo-org/tinygo/issues/4959 This makes sure to emit an error instead of generating inline assembly, which leads to hard-to-debug linker errors. Instead, it will now produce errors like the following: # golang.org/x/sys/unix ../../../../pkg/mod/golang.org/x/sys@v0.0.0-20220722155257-8c9f86f7a55f/unix/affinity_linux.go:20:23: system calls are not supported: target emulates a linux/arm system on wasm32 ../../../../pkg/mod/golang.org/x/sys@v0.0.0-20220722155257-8c9f86f7a55f/unix/fcntl.go:17:29: system calls are not supported: target emulates a linux/arm system on wasm32 ../../../../pkg/mod/golang.org/x/sys@v0.0.0-20220722155257-8c9f86f7a55f/unix/fcntl.go:32:24: system calls are not supported: target emulates a linux/arm system on wasm32	2025-10-23 10:13:29 +02:00
Elias Naur	35e6b8a67d	compileopts: lower "large stack" limit to 16kb I'm running with `-stack-size 16kb` and running into excessive allocations because the otherwise non-escaping buffer in https://github.com/golang/go/blob/c53cb642deea152e28281133bc0053f5ec0ce358/src/crypto/internal/fips140/sha512/sha512block.go#L97 is moved to the heap.	2025-10-22 13:04:24 +02:00
Ayke van Laethem	8a31ae14a0	machine: use larger SPI MAXCNT on nrf52833 and nrf52840 These chips have a larger upper limit for the DMA transfer than the nrf52832. For best performance, we should be splitting the transfer in as large blocks as possible on the given hardware.	2025-10-21 13:33:13 +02:00
Ayke van Laethem	26ee3fb93e	wasm: fix C realloc and optimize it a bit - Do not use make([]byte, ...) to allocate, instead call the allocator directly with a nil (undefined) layout. This makes sure the precise GC will scan the contents of the allocation, since C could very well put pointers in there. - Simplify the map to use the pointer as the key and the size as the value, instead of storing the slices directly in the map.	2025-10-20 12:58:11 +02:00
Ayke van Laethem	8872d5ebfc	runtime: fix sleep duration for long sleeps Long sleep durations weren't implemented correctly, by simply casting to a smaller number of bits. What we want is a saturating downcast, which is what I've used here instead. This should fix https://github.com/tinygo-org/tinygo/issues/3356.	2025-10-16 17:20:50 +02:00
deadprogram	faf455283d	chore: update all CI builds to use latest stable Go release. Also update some of the actions to their latest releases. Signed-off-by: deadprogram <ron@hybridgroup.com>	2025-10-16 09:04:00 +02:00
tinkerator	562b4c5020	Create "pico2-ice" target board (#5062 ) * Create "pico2-ice" target board This board has an rp2350b chip on it, as well as a Lattice Semiconductor iCE40UP5K FPGA. More details of this open hardware board here: https://pico2-ice.tinyvision.ai/ Tested on a pico2-ice board with: ~/go/bin/tinygo flash -target=pico2-ice src/examples/blinky1/blinky1.go which blinks the GREEN LED (connected to GPIO0) on this board. Signed-off-by: Tinkerer <tinkerer@zappem.net> * More silkscreen labels for pico2-ice board Reading the schematic and the rev2 board viewer: https://raw.githubusercontent.com/tinyvision-ai-inc/pico2-ice/refs/heads/main/Board/Rev2/bom/ibom.html concluded that the RP2350B GPIO pins are not labeled with these pin numbers in the silkscreen. Instead, the silkscreen refers to uses of the GPIOs or the ICE numbered pins. RP2340B devoted pins map to the A1..4 B1..4 pins on the RP PMOD connector. Also silkscreen "~0".."~6" are labeled as pins N0..N6. Signed-off-by: Tinkerer <tinkerer@zappem.net> * Added a smoketest for pico2-ice board and tidied up GPIO defs Addresses review comments from aykevl. Signed-off-by: Tinkerer <tinkerer@zappem.net>	2025-10-13 13:19:04 +02:00
Ayke van Laethem	7460734522	compiler: mark string parameters as readonly Strings are readonly, but the compiler doesn't always know this. Marking them as readonly in the frontend allows the compiler to optimize based on this knowledge. This provides some small code size benefits. I didn't measure running speed.	2025-10-11 23:03:18 +02:00
Olaf Flebbe	3be7100e89	fix(rp2): possible integer overflow while computing factors for SPI baudrate Incorrect factors are calculated for baudrates which are a bit larger than integer multiples of 4194304. For example for baudrates of 8_400_000 or 58_800_000. Fixed the same way in newer versions of the RPI SDK.	2025-10-09 11:48:27 +02:00