cmd/compile: missed bounds check elimination when paired slices are resliced

[FiloSottile]

go version devel go1.24-140308837f Mon Oct 21 15:30:47 2024 +0200 darwin/arm64

When the lengths of two slices are "paired" (dst = dst[:len(src)]), the compiler is smart enough to apply ifs to both, but if you reslice them the pairing is lost.

func foo(src, dst []byte) {
	dst = dst[:len(src)]
	for len(src) >= 50 {
		_ = (*[50]byte)(src) // no bounds check
		_ = (*[50]byte)(dst) // no bounds check
	}
}

func bar(src, dst []byte) {
	dst = dst[:len(src)]
	for len(src) >= 50 {
		src = src[50:] // no bounds check
		dst = dst[50:] // bounds check!
	}
}

[gabyhelp]

Related Issues and Documentation

• cmd/compile: bce: if slice[n] is in bounds, then slice[:n+1] should have bounds check eliminated #32431 (closed)
• cmd/compile: unnecessary bounds check for position len/2 #27249 (closed)
• cmd/compile: No BCE for len(x)&y in slice expression #52563 (closed)
• cmd/compile: teach prove about slice expressions #28941
• cmd/compile: improve BCE to detect safe unbounded slicing #35483 (closed)
• cmd/compile: don't generate call to growslice if the slice has capacity #33853 (closed)
• cmd/compile: unnecessary bounds check with slice offset #66691
• cmd/compile: missing BCE optimization cases #64272
• cmd/compile: Prove doesn't understand division of slice length #57077 (closed)
• cmd/compile: No BCE for str[len(str):] #53409 (closed)

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

[randall77]

I'm not sure how we'd do this.

In the former case, there's no modifications to src or dst (after the first slicing), so when we conclude that len(src)==len(dst) after the first slicing, it continues to hold throughout the rest of the function.

In the latter case, src and dst are modified in the loop. So we not only need to know that len(src)==len(dst) at the start, but that src=src[50:];dst=dst[50:] maintains that invariant. And that we never use that invariant between those two statements (where it would not hold).

We don't have any mechanism for that kind of logic in the compiler right now. I'm not sure how we would do it.

(That first function doesn't make much sense to me. An infinite loop is probably not the intent.)

[FiloSottile]

I don't always know what's doable and what is not, so when in doubt I file :)

The first function was just to show there is some awareness of len(src)==len(dst). Should have been an if not a for.

[zigo101]

When for is replaced with if, then the check is removed.

[edit]: it is indeed a problem in reality:

func bar(src, dst []byte) {
	dst = dst[:len(src)]
	for len(src) >= 2 {
		dst[1] = // Found IsInBounds
			src[0]
		dst[0] = src[1]
		src = src[2:]
		dst = dst[2:]
	}
}