cmd/compile: known bits and prove constant folding can impede memcombine

[Jorropo]

Go version

go version go1.27-devel_53bcf27018 Tue May 5 01:08:30 2026 +0200 linux/amd64

Output of go env in your module/workspace:

AR='ar'
CC='gcc'
CGO_CFLAGS='-O2 -g'
CGO_CPPFLAGS=''
CGO_CXXFLAGS='-O2 -g'
CGO_ENABLED='1'
CGO_FFLAGS='-O2 -g'
CGO_LDFLAGS='-O2 -g'
CXX='g++'
GCCGO='gccgo'
GO111MODULE=''
GOAMD64='v3'
GOARCH='amd64'
GOAUTH='netrc'
GOBIN=''
GOCACHE='/tmp/go-build'
GOCACHEPROG=''
GODEBUG=''
GOENV='/home/hugo/.config/go/env'
GOEXE=''
GOEXPERIMENT=''
GOFIPS140='off'
GOFLAGS=''
GOGCCFLAGS='-fPIC -m64 -pthread -Wl,--no-gc-sections -fmessage-length=0 -ffile-prefix-map=/tmp/go-build2419463057=/tmp/go-build -gno-record-gcc-switches'
GOHOSTARCH='amd64'
GOHOSTOS='linux'
GOINSECURE=''
GOMOD='/home/hugo/k/go/src/go.mod'
GOMODCACHE='/home/hugo/go/pkg/mod'
GONOPROXY=''
GONOSUMDB=''
GOOS='linux'
GOPATH='/home/hugo/go'
GOPRIVATE=''
GOPROXY='https://proxy.golang.org,direct'
GOROOT='/home/hugo/k/go'
GOSUMDB='sum.golang.org'
GOTELEMETRY='local'
GOTELEMETRYDIR='/home/hugo/.config/go/telemetry'
GOTMPDIR=''
GOTOOLCHAIN='local'
GOTOOLDIR='/home/hugo/k/go/pkg/tool/linux_amd64'
GOVCS=''
GOVERSION='go1.27-devel_53bcf27018 Tue May 5 01:08:30 2026 +0200'
GOWORK=''
PKG_CONFIG='pkg-config'

What did you do?

Add theses two tests to test/codegen/memcombine.go:

func store_le_byte_8_known_bits(b []byte, val uint64) {
	_ = b[8]
	val &= 0xff00ff00ff00ff00
	val |= 0x0012003400560078
	// arm64:`MOVD R[0-9]+, 1\(R[0-9]+\)` -`MOVB` -`MOVH` -`MOVW`
	// amd64:`MOVQ [A-Z]+, 1\([A-Z]+\)` -`MOVB` -`MOVW` -`MOVL`
	// ppc64le:`MOVD ` -`MOVW`
	// ppc64:`MOVDBR `
	b[1], b[2], b[3], b[4], b[5], b[6], b[7], b[8] = byte(val), byte(val>>8), byte(val>>16), byte(val>>24), byte(val>>32), byte(val>>40), byte(val>>48), byte(val>>56)
}

func store_be_byte_8_known_bits(b []byte, val uint64) {
	_ = b[8]
	val &= 0xff00ff00ff00ff00
	val |= 0x0012003400560078
	// arm64:`REV` `MOVD R[0-9]+, 1\(R[0-9]+\)` -`MOVB` -`MOVH` -`MOVW` -`REV16W` -`REVW`
	// amd64/v1,amd64/v2:`MOVQ [A-Z]+, 1\([A-Z]+\)` -`MOVB` -`MOVW` -`MOVL`
	// amd64/v3:`MOVBEQ [A-Z]+, 1\([A-Z]+\)` -`MOVBEL`
	// ppc64le:`MOVDBR`
	// ppc64:`MOVD`
	b[1], b[2], b[3], b[4], b[5], b[6], b[7], b[8] = byte(val>>56), byte(val>>48), byte(val>>40), byte(val>>32), byte(val>>24), byte(val>>16), byte(val>>8), byte(val)
}

The optimal solutions include a 64 bits store.

However the problem is that we run known bits before memcombine.
So known bits sees byte(...) operations it knows the result to and replace them with a byte store from a constant.

This removes the information memcombine needs to do her work.

[Jorropo]

This isn't too bad, afaik the only occurrence I could find is in encoding/base64.(*Encoding).Decode.

I have a couple of work around ideas like temporarily removing support OpTrunc support from known bits.

But I think we need to move memcombine much earlier such that it runs before known bits (*and prove).
We could move known bits a bit later but not after memcombine since we need to run opt after known bits (right now we rely on late opt to do that).

---

*I also think prove's constant folding logic is able to create the same bug but only on the upper part of the numbers.

[Jorropo]

I'm intentionally not adding release blocker because the same bug exists in prove ever since 1.19 e1e056f
(also this is at a worst an extremely small codesize and performance issue)

However prove is more limited here and less likely to actually create the bug so maybe this warrants it.

[Jorropo]

cc @golang/compiler

[dmitshur]

From triage, this sounds like an enhancement. @Jorropo Are you planning to work on this or did you mean to report it so someone else can pick this up?

[Jorropo]

Give me 2 year's I'll probably have fixed it by then.
But for now I don't plan to work on it. 🙂