go1.26 linux/arm64: minimal godebug-style wrapper crashes with nil pointer dereference

[cpunion]

On goplus/main, a small godebug-style wrapper package crashes under llgo on linux/arm64 + go1.26.0.

This is a reduced repro for the pattern used by Go 1.26's crypto/internal/fips140deps/godebug wrapper:

• current package name and imported package name are both godebug
• type Setting godebug.Setting
• pointer reinterpretation between *Setting and *godebug.Setting

Expected: the program prints OK.
Actual: llgo run . panics with invalid memory address or nil pointer dereference.

Minimal repro

internal/godebug/godebug.go

package godebug

import "sync"

type Setting struct {
	name string
	once sync.Once
}

func New(name string) *Setting {
	return &Setting{name: name}
}

func (s *Setting) Value() string {
	s.once.Do(func() {
		if s.name == "" {
			s.name = "default"
		}
	})
	return s.name
}

godebug/godebug.go

package godebug

import "github.com/goplus/llgo/_demo/go/godebug_alias_run/internal/godebug"

type Setting godebug.Setting

func New(name string) *Setting {
	return (*Setting)(godebug.New(name))
}

func (s *Setting) Value() string {
	return (*godebug.Setting)(s).Value()
}

func Value(name string) string {
	return godebug.New(name).Value()
}

main.go

package main

import (
	"fmt"

	"github.com/goplus/llgo/_demo/go/godebug_alias_run/godebug"
)

func main() {
	if got := godebug.Value("hello"); got != "hello" {
		panic(fmt.Sprintf("Value(hello)=%q, want hello", got))
	}
	if got := godebug.New("world").Value(); got != "world" {
		panic(fmt.Sprintf("New(world).Value()=%q, want world", got))
	}
	if got := godebug.New("").Value(); got != "default" {
		panic(fmt.Sprintf("New(\"\").Value()=%q, want default", got))
	}
	fmt.Println("OK")
}

Repro matrix

Pass

Ordinary Go toolchain:

cd _demo/go/godebug_alias_run
go run .
# OK

llgo on linux/arm64 + go1.24.2:

./dev/docker.sh arm64 bash -lc 'cd /repo && cd _demo/go/godebug_alias_run && /repo/dev/llgo.sh run .'
# OK

Fail

llgo on linux/arm64 + go1.26.0:

./dev/docker.sh arm64 bash -lc 'set -euo pipefail; cd /repo; export GOTOOLCHAIN=go1.26.0; cd _demo/go/godebug_alias_run; /repo/dev/llgo.sh run .'

Output:

panic: runtime error: invalid memory address or nil pointer dereference

[0xB023DAD8 (null)+0x0, SP = 0xb02bade8]
[0xB023DB14 (null)+0x0, SP = 0xb02bade8]
[0xB01B4060 (null)+0x0, SP = 0xb02bade8]
[0xB01B4038 (null)+0x0, SP = 0xb02bade8]
[0xB0192C78 (null)+0x0, SP = 0xb02bade8]
[0xB0190A38 (null)+0x0, SP = 0xb02bade8]
[0xB01901A4 (null)+0x0, SP = 0xb02bade8]
[0xB0176E20 (null)+0x0, SP = 0xb02bade8]
[0xB016A3E4 (null)+0x0, SP = 0xb02bade8]
[0xB0167484 (null)+0x0, SP = 0xb02bade8]
[0xB0167440 (null)+0x0, SP = 0xb02bade8]
[0x9AC384C4 (null)+0x0, SP = 0xb02bade8]
[0x9AC38598 __libc_start_main+0x11, SP = 0x98]
[0xB0167330 __libc_start_main+0x11, SP = 0x98]
exit status 2

Notes

I also tried linux/amd64 + go1.26.0, but that path currently fails earlier on an existing blocker:

internal/runtime/gc/scan: .../expand_amd64.s: missing Go declaration for asm symbol "expandAVX512_1"

So the reduced repro above is confirmed on linux/arm64, and not yet isolated on linux/amd64 because of that earlier failure.

[cpunion]

@xgopilot analyze

[fennoai]

Analysis of Issue #1757

Root Cause: Missing atomic.Bool in LLGo's sync/atomic Replacement

The crash is caused by a combination of Go 1.26's sync.Once struct layout change and LLGo's incomplete sync/atomic replacement package.

---

Go 1.26 sync.Once Layout Change

Go 1.24 sync.Once:

type Once struct {
    _ noCopy
    done atomic.Uint32   // 4 bytes
    m    Mutex
}

Go 1.26 sync.Once:

type Once struct {
    noCopy noCopy
    done   atomic.Bool   // 1 byte (changed from atomic.Uint32)
    m      Mutex
}

Key changes:

1. done field changed from atomic.Uint32 to atomic.Bool
2. noCopy changed from blank _ to named field noCopy

Missing atomic.Bool in LLGo

LLGo replaces the standard sync/atomic package with its own implementation at runtime/internal/lib/sync/atomic/. This replacement package currently defines:

• Int64, Uint64 (type.go)
• Value (value.go)
• noCopy, align64 helpers
• All the atomic functions (Load*, Store*, Swap*, CompareAndSwap*, Add*, And*, Or*)

It does NOT define: Bool, Int32, Uint32, or Pointer[T] types.

Since sync/atomic is registered as altPkgReplace in runtime/build.go:36, LLGo completely replaces the standard sync/atomic package. When Go 1.26's sync.Once references atomic.Bool, the type cannot be found in the replacement package.

How This Causes the Nil Pointer Dereference

1. The sync package is compiled using the standard Go source (it's NOT in altPkgs)
2. sync.Once references atomic.Bool from Go 1.26's standard library
3. During type resolution, atomic.Bool is resolved against LLGo's replacement sync/atomic package
4. Since atomic.Bool doesn't exist in the replacement, the type resolution either:
   • Falls through to an incorrect/nil type
   • Creates a struct with misaligned fields due to wrong type layout
5. When the repro code creates a Setting struct containing sync.Once, the struct layout is corrupted
6. Method calls on this struct dereference corrupted pointers, causing the nil pointer panic

This explains why:

• Go 1.24 works: sync.Once uses atomic.Uint32, which doesn't need to be in the replacement (the Uint32 functions work at the raw level)
• Standard go run works: Standard Go doesn't replace sync/atomic
• LLGo + Go 1.26 crashes: The missing atomic.Bool type in the replacement causes struct layout corruption

The Godebug Pattern Amplifies the Issue

The specific godebug wrapper pattern (same package name, type definition, pointer reinterpretation) amplifies the issue because:

• type Setting godebug.Setting creates a new named type with sync.Once embedded
• Pointer conversions between *Setting and *godebug.Setting rely on identical struct layouts
• If sync.Once has a corrupted layout, both types are corrupted, and any method call crashes

---

Proposed Fix

Primary fix: Add missing atomic types to runtime/internal/lib/sync/atomic/type.go:

// A Bool is an atomic boolean. The zero value is false.
type Bool struct {
    _ noCopy
    v uint32
}

func (x *Bool) Load() bool            { return LoadUint32(&x.v) != 0 }
func (x *Bool) Store(val bool)        { StoreUint32(&x.v, b32(val)) }
func (x *Bool) Swap(new bool) (old bool) { return SwapUint32(&x.v, b32(new)) != 0 }
func (x *Bool) CompareAndSwap(old, new bool) (swapped bool) {
    return CompareAndSwapUint32(&x.v, b32(old), b32(new))
}

func b32(b bool) uint32 { if b { return 1 }; return 0 }

// An Int32 is an atomic int32. The zero value is zero.
type Int32 struct {
    _ noCopy
    v int32
}

func (x *Int32) Load() int32            { return LoadInt32(&x.v) }
func (x *Int32) Store(val int32)        { StoreInt32(&x.v, val) }
func (x *Int32) Swap(new int32) (old int32) { return SwapInt32(&x.v, new) }
func (x *Int32) CompareAndSwap(old, new int32) (swapped bool) {
    return CompareAndSwapInt32(&x.v, old, new)
}
func (x *Int32) Add(delta int32) (new int32) { return AddInt32(&x.v, delta) }
func (x *Int32) And(mask int32) (old int32) { return AndInt32(&x.v, mask) }
func (x *Int32) Or(mask int32) (old int32) { return OrInt32(&x.v, mask) }

// A Uint32 is an atomic uint32. The zero value is zero.
type Uint32 struct {
    _ noCopy
    v uint32
}

func (x *Uint32) Load() uint32            { return LoadUint32(&x.v) }
func (x *Uint32) Store(val uint32)        { StoreUint32(&x.v, val) }
func (x *Uint32) Swap(new uint32) (old uint32) { return SwapUint32(&x.v, new) }
func (x *Uint32) CompareAndSwap(old, new uint32) (swapped bool) {
    return CompareAndSwapUint32(&x.v, old, new)
}
func (x *Uint32) Add(delta uint32) (new uint32) { return AddUint32(&x.v, delta) }
func (x *Uint32) And(mask uint32) (old uint32) { return AndUint32(&x.v, mask) }
func (x *Uint32) Or(mask uint32) (old uint32) { return OrUint32(&x.v, mask) }

// A Uintptr is an atomic uintptr. The zero value is zero.
type Uintptr struct {
    _ noCopy
    v uintptr
}

func (x *Uintptr) Load() uintptr            { return LoadUintptr(&x.v) }
func (x *Uintptr) Store(val uintptr)        { StoreUintptr(&x.v, val) }
func (x *Uintptr) Swap(new uintptr) (old uintptr) { return SwapUintptr(&x.v, new) }
func (x *Uintptr) CompareAndSwap(old, new uintptr) (swapped bool) {
    return CompareAndSwapUintptr(&x.v, old, new)
}
func (x *Uintptr) Add(delta uintptr) (new uintptr) { return AddUintptr(&x.v, delta) }
func (x *Uintptr) And(mask uintptr) (old uintptr) { return AndUintptr(&x.v, mask) }
func (x *Uintptr) Or(mask uintptr) (old uintptr) { return OrUintptr(&x.v, mask) }

Secondary: Also add the repro as a test case in _demo/go/godebug_alias_run/ and potentially in _cmptest/.

Key Files

File	Role
runtime/internal/lib/sync/atomic/type.go	Missing Bool, Int32, Uint32, Uintptr types
runtime/build.go:36	sync/atomic registered as altPkgReplace
runtime/internal/lib/runtime/sema_llgo.go	Runtime linknames for sync semaphore ops
ssa/type.go:536-568	toNamed() - named type resolution
cl/compile.go:1311-1349	_patchType() - type patching during compilation

View job run