cmd/compile: missed optimization for consecutive byte stores

[renthraysk]

Go version

go version go1.26.4 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='v1'
GOARCH='amd64'
GOAUTH='netrc'
GOBIN=''
GOCACHE='/home/ren/.cache/go-build'
GOCACHEPROG=''
GODEBUG=''
GOENV='/home/ren/.config/go/env'
GOEXE=''
GOEXPERIMENT=''
GOFIPS140='off'
GOFLAGS=''
GOGCCFLAGS='-fPIC -m64 -pthread -Wl,--no-gc-sections -fmessage-length=0 -ffile-prefix-map=/tmp/go-build2978298927=/tmp/go-build -gno-record-gcc-switches'
GOHOSTARCH='amd64'
GOHOSTOS='linux'
GOINSECURE=''
GOMOD='/dev/null'
GOMODCACHE='/home/ren/go/pkg/mod'
GONOPROXY=''
GONOSUMDB=''
GOOS='linux'
GOPATH='/home/ren/go'
GOPRIVATE=''
GOPROXY='https://proxy.golang.org,direct'
GOROOT='/usr/local/go'
GOSUMDB='sum.golang.org'
GOTELEMETRY='local'
GOTELEMETRYDIR='/home/ren/.config/go/telemetry'
GOTMPDIR=''
GOTOOLCHAIN='auto'
GOTOOLDIR='/usr/local/go/pkg/tool/linux_amd64'
GOVCS=''
GOVERSION='go1.26.4'
GOWORK=''
PKG_CONFIG='pkg-config'

What did you do?

func f(p []byte, x, y uint32) {
    _ = p[7]
    p[0] = byte(x >> 24)
    p[1] = byte(x >> 16)
    p[2] = byte(x >> 8)
    p[3] = byte(x)
    p[4] = byte(y >> 24)
    p[5] = byte(y >> 16)
    p[6] = byte(y >> 8)
    p[7] = byte(y)
}

What did you see happen?

BSWAP x
MOVL  x, (dst)

Followed by a MOVB & SHRL sequence for storing y.

What did you expect to see?

BSWAP x
MOVL  x, (dst)
BSWAP y
MOVL  y, 4(dst)

[gabyhelp]

Related Issues

• cmd/compile: memcombine does not combine stores separated by OpLocalAddr #70300 (closed)
• cmd/compile: store combining doesn't combine all possible stores #60709 (closed)
• cmd/compile: missing combine constant store cases on amd64 #53324 (closed)
• cmd/compile: multiple LittleEndian.Uint* calls on the same buffer block load merging #52708 (closed)
• cmd/compile: missed opportunity to coalesce reads/writes #41663 (closed)
• cmd/compile: memcombine should learn alignment of byte slices - hard mode - arithmetic #71780
• cmd/compile: eliminate redundant zeroing after lower pass #47107 (closed)
• cmd/compile: Use wide integer load/store instructions if possible #11819 (closed)
• cmd/compile: memcombine should learn allignement of byte slices - easy mode - types #71778

Related Code Changes

• cmd/compile/internal/ssa: generate bswap/store for indexed bigendian byte stores too on AMD64

_{(Emoji vote if this was helpful or unhelpful; more detailed feedback welcome in this discussion.)}

[Jorropo]

I've reproed and root caused.
The thing is this loop:

	// Pick the largest mergeable set.
	for _, s := range []int64{8, 4, 2} {
		candidate := mergeableSet[s]
		// TODO: a refactoring might be more efficient:
		// Find a bunch of stores that are all adjacent and then decide how big a chunk of
		// those sequential stores to combine.
		if len(candidate) >= 2 {
			// Before we sort, grab the memory arg the result should have.
			mem = candidate[len(candidate)-1].store.Args[2]
			// Also grab position of first store (last in array = first in memory order).
			pos = candidate[len(candidate)-1].store.Pos
			// Sort stores in increasing address order.
			slices.SortFunc(candidate, func(sr1, sr2 StoreRecord) int {
				return cmp.Compare(sr1.offset, sr2.offset)
			})
			// Check that everything is written to sequential locations.
			sequential := true
			for i := 1; i < len(candidate); i++ {
				if candidate[i].offset != candidate[i-1].offset+candidate[i-1].size {
					sequential = false
					break
				}
			}
			if sequential {
				a = candidate
				aTotalSize = s
				break
			}
		}
	}

It picks the biggest possible block of adjacent memory operations and try to merge it.
Then later down the line the code make sure the source are identical and removes different sources but doing so it might consume only part of the candidates.