Release 0.42.0

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

CHANGELOG.md

@@ -1,3 +1,162 @@
+0.42.0
+---
+* **general**
+  - all: add LLVM 22 support, and support LLVM 19 and LLVM 20 on Fedora 43
+  - all: build and test using Go 1.27, and raise the max supported Go version to 1.27
+  - all: modernize and clean up code with Go 1.24+ in mind (#5489, #5498)
+  - all: use unsafe.SliceData where appropriate
+  - all: update golang.org/x/tools and go-llvm
+  - cli: add basic probe-rs support
+  - cli: clarify the runtime.alloc linker error with -gc=none
+  - main: allow the -o flag to point to a directory
+  - main: make the -monitor flag on flash respect the port
+  - main: update to espflasher 0.8.0 with fixes for esp32c3 and esp32s3
+  - cgo: add CGO_CFLAGS support (#5453)
+  - version: update to 0.42.0 for the new dev cycle
+  - docs: add agents.md guideline for use of ASD-STE100 (#5566)
+* **compiler**
+  - compiler, runtime: make runtime, map, and channel panics recoverable
+  - compiler, runtime: support recover on riscv64
+  - compiler, runtime, reflect: generate type-specific hash/equal (#5359)
+  - support Go 1.27 generic methods via the x/tools upgrade
+  - canonicalize generic instance and method signature identities
+  - disambiguate function-local named types and generic instance link names (#5336)
+  - exclude generic methods from runtime method sets
+  - support file-level //go:linkname directives and the //go:linknamestd pragma
+  - add the //go:noheap pragma
+  - pass large aggregates by pointer
+  - use LLVM intrinsics for math trig operations
+  - optimize zero-sized allocations
+  - consistently pass layout and alignment to createAlloc
+  - handle nested unsigned shift being untyped after type resolution (#5497)
+  - store the defer list head in the defer frame and centralize deferred call records
+  - centralize SSA loads, stores, result handling, and LLVM function type construction
+  - transform, compiler: support the captures(none) attribute of LLVM 21
+* **core**
+  - reflect: add Type.ConvertibleTo and complex, rune, and integer string conversions
+  - reflect: implement MakeChan
+  - reflect: add missing iterator methods
+  - reflect, reflectlite: make IsRO and MakeRO package methods
+  - sync: add Map.CompareAndSwap and Map.CompareAndDelete
+  - sync: fix deadlock in the Map.Range callback
+  - os, syscall: add Statfs and Fstatfs stubs and Getpagesize for non-hosted targets
+  - os: add File.Chown on the unix path
+  - runtime, syscall, internal/poll, os: wasip1 poll_oneoff scheduler integration and net.FileListener (#5386)
+  - runtime, testing: support Goexit, SkipNow, and FailNow
+  - syscall: remove sliceHeader, use unsafe.SliceData more
+  - builder, cgo, syscall: replace fixed-size array casts with unsafe.Slice
+  - builder, loader: fix -ldflags -X not overriding variables with default values
+  - builder: build SSA before compiling packages
+  - builder: increase the stack size margin for automatic stack allocation
+  - builder: do not count non-writable SHT_NOBITS sections as RAM or bss
+  - builder: link stack probes on Windows amd64 and arm64, and add chkstk2.S for windows/386
+  - builder: add strlen to the wasm builtins
+  - builder: retry cached archive renames on Windows (#5462)
+  - loader: avoid a race condition when loading the package list, and skip object resolution
+  - interp: bail out of loops that iterate too many times (#5395)
+  - interp: fix partial store aliasing and avoid repeated object clones
+  - interp: defer out-of-bounds loads to runtime instead of crashing
+  - interp: mark pointers in aggregate call operands as external
+  - interp: fix switch-instruction handling for the new case-value API of LLVM 22
+  - transform: follow returned pointer and aggregate alloc aliases
+  - transform: add -print-allocs-cover and restore the -print-allocs reason output
+  - device: add device/uefi and device/amd64
+  - wasm: patch wasm_exec.js and wasm_exec_node.js from Go 1.18+ (#5483)
+* **net**
+  - update the net module with a roundtrip fix for js/wasm
+* **runtime**
+  - make divide-by-zero and nil dereference panics recoverable
+  - add a Windows vectored exception handler for recoverable panics
+  - make Goexit exit host threads, and encode a pending Goexit in the panic state
+  - make out-of-memory and fatal failures unrecoverable
+  - improve the hardfault handler and stack reporting on Cortex-M
+  - prevent timer starvation in the cores scheduler
+  - do not access the timer queue outside of the lock
+  - fix ticker not stopping when Stop races with its callback (#5487)
+  - wake channel waiters after releasing locks (#5513)
+  - implement SetFinalizer and run syscall/js finalizers without a manual GC (#5545)
+  - implement MemStats.NumGC
+  - add runtime.fastrandn (#5502)
+  - make arrays and struct field hashes order dependent
+  - add critical-section fallbacks for atomic And and Or
+  - gc: pause all cores before scanning the stack and globals
+  - gc: correct the old size calculation in block realloc
+  - gc: correct the leaking allocator bounds and overflow checks
+  - gc: move objHeader to the end of the block header
+  - fix the leaking GC build with the cores scheduler
+  - rp2040: fix -gc=leaking and -gc=none
+  - rp2: handle the RP2350 shared FIFO IRQ for GC (#5482)
+  - esp32c6: select the 80MHz PLL as the TIMG0 timer clock source
+  - split baremetal memory setup and the Windows PE globals scan for UEFI (#5360, #5361)
+* **machine**
+  - usb: support bidirectional endpoints by dynamic registration on RP2, SAMD21/51, and nRF52840 (#5447)
+  - usb: generate endpoint descriptors dynamically
+  - usb: implement endpoint stall for nRF52840
+  - usb: fix a truncated string descriptor when the host requests a short maxLen (#5449)
+  - usb: add USBDevice.Attach and USBDevice.Detach (#5563)
+  - usb/cdc: fix the RP2 USB CDC TX race with the cores scheduler (#5391)
+  - add UART line inversion support (#5522)
+  - optimize RTT initialization
+  - device/arm: add ARM v7-M MPU support
+  - esp32: add interrupt support with vector table, timer alarm, and GPIO SetInterrupt
+  - esp32: add interrupt-based UART RX and fix the init order
+  - esp32: implement flash XIP (execute-in-place) support
+  - esp32: add ADC driver (#5595)
+  - esp32: fix pullup and pulldown on RTC GPIO pins
+  - esp32: remove dead code and fix GC root scanning
+  - esp32: configure UARTs to the specified pins and yield while waiting for the buffer
+  - esp32, esp32s3: fix the boot crash caused by the LLVM 22 lld l32r relocation bug
+  - esp32s3: fix register-window corruption under interrupt load
+  - esp32s3: add temperature reading
+  - esp32c6: add a minimal implementation with I2C and ADC support
+  - stm32: fix UART transmission, baud rate, and interrupt handling
+  - stm32: add an OTG FS USB driver for F4 and F7
+  - stm32: add STM32H7 and NUCLEO-H753ZI support
+  - stm32: add support for the STM32U031 chip
+  - stm32: make the HSE crystal frequency selectable
+  - stm32u5: configure the system clock to 160 MHz
+  - nrf: avoid a too high priority interrupt on SoftDevice
+  - rp2: allow SPI transmit-only without SDI (#5437)
+  - rp2: clear the USB buffer status before the endpoint handlers
+  - rp2350: fix the ROM CS control for the RP2350 ROM code
+  - add GP aliases for waveshare-rp2040-zero
+  - gba: add support for mGBA debugging
+  - gba: add bios interrupt flags and sound register constants (#5445)
+* **targets**
+  - add minimal uefi target support with the LinkerFlavor option (#5452, #5465)
+  - uefi: add support for UEFI time and events, fix STOP newline conversion (#5549)
+  - uefi: add support for the tasks scheduler and make it the default (#5553)
+  - add Puya PY32F MCU support (#5106)
+  - add esp32s3-box-3 (#5388)
+  - add M5Stack Stamp-S3A (#5524)
+  - add Pimoroni Blinky 2350 and Badger 2350 (#5434)
+  - add the 'Plus' board variant of SeeedStudio XIAO nrf52840 (#5479)
+  - esp32: adjust memory usage, add DRAM1 sections, and export the symbols needed for wifi
+  - esp32c3: add the BT ROM functions to the linker
+  - esp32: add the espradio tag for convenience
+  - builder: fix esp32 XIP so large programs flash correctly, including QEMU image offsets
+  - wasm_exec.js: add runtime.getRandomData to the gojs imports, coerce memory offsets to unsigned, and reset _pendingEvent
+* **libs**
+  - update macos-minimal-sdk to v0.1.0
+* **build/test**
+  - ci: run the full smoke test once, and split the GNUmakefile (#5616)
+  - ci: publish a draft release from the artifacts that CI already built
+  - ci: stop the LLVM caches from being evicted
+  - ci: modify builds to use LLVM 22
+  - ci: add a check for compatibility with older Go and LLVM versions
+  - ci: add a job to make sure go.sum stays in sync with go.mod
+  - ci: re-add fmt-check, and remove the CircleCI configuration
+  - ci: adjust runner sizes for Linux, Windows, and macOS
+  - build: statically link the MinGW runtime in the LLVM tools on Windows
+  - Makefile: use ${LLVM_PROJECTDIR} during the copy phase
+  - GNUmakefile: disable DWARF compression for CGo objects, and update the stdlib test lists
+  - test: run ESP32 programs in QEMU
+  - test: support simavr 1.8+
+  - test: normalize LLVM IR when updating goldens
+  - test: convert TestBinarySize to a golden file test
+  - testdata: add regression tests for generic instances, generic aliases, and large aggregates
+  - test: skip flaky and Go 1.27 affected tests for now
+
 0.41.1
 ---
 * **machine**

compiler/map.go

@@ -417,7 +417,6 @@ func (b *builder) generateKeyHash(keyType types.Type, llvmKeyType llvm.Type, key
 		return b.createRuntimeCall("hashmapInterfacePtrHash", []llvm.Value{keyPtr, size, seed}, "hash")
 	case *types.Struct:
 		hash := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
-		multiplier := llvm.ConstInt(b.ctx.Int32Type(), 31, false)
 		zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
 		for i := 0; i < keyType.NumFields(); i++ {
 			if keyType.Field(i).Name() == "_" {
@@ -431,7 +430,7 @@ func (b *builder) generateKeyHash(keyType types.Type, llvmKeyType llvm.Type, key
 			idx := llvm.ConstInt(b.ctx.Int32Type(), uint64(i), false)
 			fieldPtr := b.CreateInBoundsGEP(llvmKeyType, keyPtr, []llvm.Value{zero, idx}, "")
 			fieldHash := b.generateKeyHash(fieldType, llvmFieldType, fieldPtr, seed)
-			hash = b.CreateXor(b.CreateMul(hash, multiplier, ""), fieldHash, "")
+			hash = b.CreateXor(hash, fieldHash, "")
 		}
 		return hash
 	case *types.Array:
@@ -446,7 +445,6 @@ func (b *builder) generateKeyHash(keyType types.Type, llvmKeyType llvm.Type, key
 		if arrayLen == 0 {
 			return llvm.ConstInt(b.ctx.Int32Type(), 0, false)
 		}
-		multiplier := llvm.ConstInt(b.ctx.Int32Type(), 31, false)
 		if arrayLen <= hashArrayUnrollLimit {
 			hash := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
 			zero := llvm.ConstInt(b.ctx.Int32Type(), 0, false)
@@ -454,7 +452,7 @@ func (b *builder) generateKeyHash(keyType types.Type, llvmKeyType llvm.Type, key
 				idx := llvm.ConstInt(b.uintptrType, uint64(i), false)
 				elemPtr := b.CreateInBoundsGEP(llvmKeyType, keyPtr, []llvm.Value{zero, idx}, "")
 				elemHash := b.generateKeyHash(elemType, llvmElemType, elemPtr, seed)
-				hash = b.CreateXor(b.CreateMul(hash, multiplier, ""), elemHash, "")
+				hash = b.CreateXor(hash, elemHash, "")
 			}
 			return hash
 		}
@@ -473,7 +471,7 @@ func (b *builder) generateKeyHash(keyType types.Type, llvmKeyType llvm.Type, key
 
 		elemPtr := b.CreateInBoundsGEP(llvmKeyType, keyPtr, []llvm.Value{zero, phiI}, "")
 		elemHash := b.generateKeyHash(elemType, llvmElemType, elemPtr, seed)
-		newHash := b.CreateXor(b.CreateMul(phiHash, multiplier, ""), elemHash, "")
+		newHash := b.CreateXor(phiHash, elemHash, "")
 		nextI := b.CreateAdd(phiI, llvm.ConstInt(b.uintptrType, 1, false), "")
 		cond := b.CreateICmp(llvm.IntULT, nextI, llvm.ConstInt(b.uintptrType, uint64(arrayLen), false), "")
 		b.CreateCondBr(cond, loopBody, loopDone)

compiler/testdata/zeromap.go

@@ -12,11 +12,6 @@ type nestedPadding struct {
 	i int
 }
 
-type stringStruct struct {
-	a string
-	b string
-}
-
 //go:noinline
 func testZeroGet(m map[hasPadding]int, s hasPadding) int {
 	return m[s]
@@ -37,21 +32,6 @@ func testZeroArraySet(m map[[2]hasPadding]int, s [2]hasPadding) {
 	m[s] = 5
 }
 
-//go:noinline
-func makeStringStructMap() map[stringStruct]int {
-	return make(map[stringStruct]int)
-}
-
-//go:noinline
-func makeShortStringArrayMap() map[[2]string]int {
-	return make(map[[2]string]int)
-}
-
-//go:noinline
-func makeLongStringArrayMap() map[[5]string]int {
-	return make(map[[5]string]int)
-}
-
 func main() {
 
 }

compiler/testdata/zeromap.ll

@@ -4,7 +4,6 @@ target datalayout = "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-i128:128-n32:64-S128-n
 target triple = "wasm32-unknown-wasi"
 
 %main.hasPadding = type { i1, i32, i1 }
-%runtime._string = type { ptr, i32 }
 
 declare void @runtime.trackPointer(ptr nocapture readonly, ptr, ptr) #0
 
@@ -98,152 +97,6 @@ entry:
   ret void
 }
 
-; Function Attrs: noinline nounwind
-define hidden ptr @main.makeStringStructMap(ptr %context) unnamed_addr #2 {
-entry:
-  %stackalloc = alloca i8, align 1
-  %0 = call ptr @runtime.hashmapMakeGeneric(i32 16, i32 4, i32 8, ptr null, ptr nonnull @"hashmapKeyHash.struct{string; string}", ptr null, ptr nonnull @"hashmapKeyEqual.struct{string; string}", ptr undef) #4
-  call void @runtime.trackPointer(ptr %0, ptr nonnull %stackalloc, ptr undef) #4
-  ret ptr %0
-}
-
-; Function Attrs: nounwind
-define linkonce_odr i32 @"hashmapKeyHash.struct{string; string}"(ptr %0, i32 %1, i32 %2, ptr %3) unnamed_addr #1 {
-entry:
-  %hash = call i32 @runtime.hashmapStringPtrHash(ptr %0, i32 8, i32 %2, ptr undef) #4
-  %4 = getelementptr inbounds nuw i8, ptr %0, i32 8
-  %hash1 = call i32 @runtime.hashmapStringPtrHash(ptr nonnull %4, i32 8, i32 %2, ptr undef) #4
-  %5 = mul i32 %hash, 31
-  %6 = xor i32 %5, %hash1
-  ret i32 %6
-}
-
-declare i32 @runtime.hashmapStringPtrHash(ptr, i32, i32, ptr) #0
-
-; Function Attrs: nounwind
-define linkonce_odr i1 @"hashmapKeyEqual.struct{string; string}"(ptr %0, ptr %1, i32 %2, ptr %3) unnamed_addr #1 {
-entry:
-  %x.str.unpack = load ptr, ptr %0, align 4
-  %x.str.elt4 = getelementptr inbounds nuw i8, ptr %0, i32 4
-  %x.str.unpack5 = load i32, ptr %x.str.elt4, align 4
-  %y.str.unpack = load ptr, ptr %1, align 4
-  %y.str.elt7 = getelementptr inbounds nuw i8, ptr %1, i32 4
-  %y.str.unpack8 = load i32, ptr %y.str.elt7, align 4
-  %eq = call i1 @runtime.stringEqual(ptr %x.str.unpack, i32 %x.str.unpack5, ptr %y.str.unpack, i32 %y.str.unpack8, ptr undef) #4
-  %4 = getelementptr inbounds nuw i8, ptr %0, i32 8
-  %5 = getelementptr inbounds nuw i8, ptr %1, i32 8
-  %x.str1.unpack = load ptr, ptr %4, align 4
-  %x.str1.elt10 = getelementptr inbounds nuw i8, ptr %0, i32 12
-  %x.str1.unpack11 = load i32, ptr %x.str1.elt10, align 4
-  %y.str2.unpack = load ptr, ptr %5, align 4
-  %y.str2.elt13 = getelementptr inbounds nuw i8, ptr %1, i32 12
-  %y.str2.unpack14 = load i32, ptr %y.str2.elt13, align 4
-  %eq3 = call i1 @runtime.stringEqual(ptr %x.str1.unpack, i32 %x.str1.unpack11, ptr %y.str2.unpack, i32 %y.str2.unpack14, ptr undef) #4
-  %6 = and i1 %eq, %eq3
-  ret i1 %6
-}
-
-declare i1 @runtime.stringEqual(ptr readonly, i32, ptr readonly, i32, ptr) #0
-
-declare ptr @runtime.hashmapMakeGeneric(i32, i32, i32, ptr, ptr, ptr, ptr, ptr) #0
-
-; Function Attrs: noinline nounwind
-define hidden ptr @main.makeShortStringArrayMap(ptr %context) unnamed_addr #2 {
-entry:
-  %stackalloc = alloca i8, align 1
-  %0 = call ptr @runtime.hashmapMakeGeneric(i32 16, i32 4, i32 8, ptr null, ptr nonnull @"hashmapKeyHash.[2]string", ptr null, ptr nonnull @"hashmapKeyEqual.[2]string", ptr undef) #4
-  call void @runtime.trackPointer(ptr %0, ptr nonnull %stackalloc, ptr undef) #4
-  ret ptr %0
-}
-
-; Function Attrs: nounwind
-define linkonce_odr i32 @"hashmapKeyHash.[2]string"(ptr %0, i32 %1, i32 %2, ptr %3) unnamed_addr #1 {
-entry:
-  %hash = call i32 @runtime.hashmapStringPtrHash(ptr %0, i32 8, i32 %2, ptr undef) #4
-  %4 = getelementptr inbounds nuw i8, ptr %0, i32 8
-  %hash1 = call i32 @runtime.hashmapStringPtrHash(ptr nonnull %4, i32 8, i32 %2, ptr undef) #4
-  %5 = mul i32 %hash, 31
-  %6 = xor i32 %5, %hash1
-  ret i32 %6
-}
-
-; Function Attrs: nounwind
-define linkonce_odr i1 @"hashmapKeyEqual.[2]string"(ptr %0, ptr %1, i32 %2, ptr %3) unnamed_addr #1 {
-entry:
-  %x.str.unpack = load ptr, ptr %0, align 4
-  %x.str.elt4 = getelementptr inbounds nuw i8, ptr %0, i32 4
-  %x.str.unpack5 = load i32, ptr %x.str.elt4, align 4
-  %y.str.unpack = load ptr, ptr %1, align 4
-  %y.str.elt7 = getelementptr inbounds nuw i8, ptr %1, i32 4
-  %y.str.unpack8 = load i32, ptr %y.str.elt7, align 4
-  %eq = call i1 @runtime.stringEqual(ptr %x.str.unpack, i32 %x.str.unpack5, ptr %y.str.unpack, i32 %y.str.unpack8, ptr undef) #4
-  %4 = getelementptr inbounds nuw i8, ptr %0, i32 8
-  %5 = getelementptr inbounds nuw i8, ptr %1, i32 8
-  %x.str1.unpack = load ptr, ptr %4, align 4
-  %x.str1.elt10 = getelementptr inbounds nuw i8, ptr %0, i32 12
-  %x.str1.unpack11 = load i32, ptr %x.str1.elt10, align 4
-  %y.str2.unpack = load ptr, ptr %5, align 4
-  %y.str2.elt13 = getelementptr inbounds nuw i8, ptr %1, i32 12
-  %y.str2.unpack14 = load i32, ptr %y.str2.elt13, align 4
-  %eq3 = call i1 @runtime.stringEqual(ptr %x.str1.unpack, i32 %x.str1.unpack11, ptr %y.str2.unpack, i32 %y.str2.unpack14, ptr undef) #4
-  %6 = and i1 %eq, %eq3
-  ret i1 %6
-}
-
-; Function Attrs: noinline nounwind
-define hidden ptr @main.makeLongStringArrayMap(ptr %context) unnamed_addr #2 {
-entry:
-  %stackalloc = alloca i8, align 1
-  %0 = call ptr @runtime.hashmapMakeGeneric(i32 40, i32 4, i32 8, ptr null, ptr nonnull @"hashmapKeyHash.[5]string", ptr null, ptr nonnull @"hashmapKeyEqual.[5]string", ptr undef) #4
-  call void @runtime.trackPointer(ptr %0, ptr nonnull %stackalloc, ptr undef) #4
-  ret ptr %0
-}
-
-; Function Attrs: nounwind
-define linkonce_odr i32 @"hashmapKeyHash.[5]string"(ptr %0, i32 %1, i32 %2, ptr %3) unnamed_addr #1 {
-entry:
-  br label %hash.array.body
-
-hash.array.body:                                  ; preds = %hash.array.body, %entry
-  %i = phi i32 [ 0, %entry ], [ %7, %hash.array.body ]
-  %hash.acc = phi i32 [ 0, %entry ], [ %6, %hash.array.body ]
-  %4 = getelementptr inbounds nuw %runtime._string, ptr %0, i32 %i
-  %hash = call i32 @runtime.hashmapStringPtrHash(ptr %4, i32 8, i32 %2, ptr undef) #4
-  %5 = mul i32 %hash.acc, 31
-  %6 = xor i32 %5, %hash
-  %7 = add nuw nsw i32 %i, 1
-  %8 = icmp samesign ult i32 %i, 4
-  br i1 %8, label %hash.array.body, label %hash.array.done
-
-hash.array.done:                                  ; preds = %hash.array.body
-  ret i32 %6
-}
-
-; Function Attrs: nounwind
-define linkonce_odr i1 @"hashmapKeyEqual.[5]string"(ptr %0, ptr %1, i32 %2, ptr %3) unnamed_addr #1 {
-entry:
-  br label %eq.array.body
-
-eq.array.body:                                    ; preds = %eq.array.body, %entry
-  %i = phi i32 [ 0, %entry ], [ %6, %eq.array.body ]
-  %4 = getelementptr inbounds %runtime._string, ptr %0, i32 %i
-  %5 = getelementptr inbounds %runtime._string, ptr %1, i32 %i
-  %x.str.unpack = load ptr, ptr %4, align 4
-  %x.str.elt1 = getelementptr inbounds nuw i8, ptr %4, i32 4
-  %x.str.unpack2 = load i32, ptr %x.str.elt1, align 4
-  %y.str.unpack = load ptr, ptr %5, align 4
-  %y.str.elt4 = getelementptr inbounds nuw i8, ptr %5, i32 4
-  %y.str.unpack5 = load i32, ptr %y.str.elt4, align 4
-  %eq = call i1 @runtime.stringEqual(ptr %x.str.unpack, i32 %x.str.unpack2, ptr %y.str.unpack, i32 %y.str.unpack5, ptr undef) #4
-  %6 = add i32 %i, 1
-  %7 = icmp ult i32 %6, 5
-  %.not7 = and i1 %7, %eq
-  br i1 %.not7, label %eq.array.body, label %eq.array.done
-
-eq.array.done:                                    ; preds = %eq.array.body
-  ret i1 %eq
-}
-
 ; Function Attrs: nounwind
 define hidden void @main.main(ptr %context) unnamed_addr #1 {
 entry:

goenv/version.go

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