| // errorcheck -0 -d=ssa/known_bits/debug=1 |
| |
| //go:build amd64 || arm64 || s390x || ppc64le || riscv64 |
| |
| // Copyright 2026 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| package a |
| |
| func knownBitsPhiAnd(cond bool) int { |
| x := 1 |
| if cond { |
| x = 3 |
| } |
| return x & 1 // ERROR "known value of v[0-9]+ \(And64\): 1$" |
| } |
| |
| func knownBitsPhiAndGarbage(cond bool, x int) int { |
| x &^= 1 |
| if cond { |
| x = 2 |
| } |
| return x & 1 // ERROR "known value of v[0-9]+ \(And64\): 0$" |
| } |
| |
| func unknownBitsPhiAnd(cond bool) int { |
| x := 1 |
| if cond { |
| x = 2 |
| } |
| return x & 1 |
| } |
| |
| func knownBitsOrGarbage(x, unknown int) int { |
| x |= 7 |
| x |= unknown &^ 3 |
| return x & 3 // ERROR "known value of v[0-9]+ \(And64\): 3$" |
| } |
| |
| func unknownBitsOrGarbage(x, unknown int) int { |
| x |= 1 |
| x |= unknown |
| return x & 3 |
| } |
| |
| func knownBitsDeferPattern(a, b bool) int { |
| bits := 0 |
| bits |= 1 << 0 |
| if a { |
| bits |= 1 << 1 |
| } |
| bits |= 1 << 2 |
| if b { |
| bits |= 1 << 3 |
| } |
| return bits & (1<<2 | 1<<0) // ERROR "known value of v[0-9]+ \(And64\): 5$" |
| } |
| |
| func knownBitsDeferPatternGarbage(a, b bool, garbage int) int { |
| bits := 0 |
| bits |= 1 << 0 |
| if a { |
| bits |= 1 << 1 |
| } |
| bits |= 1 << 2 |
| if b { |
| bits |= 1 << 3 |
| } |
| bits ^= garbage &^ (1<<2 | 1<<0) |
| return bits & (1<<2 | 1<<0) // ERROR "known value of v[0-9]+ \(And64\): 5$" |
| } |
| |
| func knownBitsXorToggle(a, b, c bool) int { |
| bits := 0 |
| bits ^= 1 << 0 |
| if a { |
| bits ^= 1 << 1 |
| } |
| bits ^= 1 << 2 |
| if b { |
| bits ^= 1 << 3 |
| } |
| bits ^= 1 << 2 |
| if c { |
| bits ^= 1 << 4 |
| } |
| return bits & (1<<2 | 1<<0) // ERROR "known value of v[0-9]+ \(And64\): 1$" |
| } |
| |
| func knownBitsXorToggleGarbage(a, b, c bool, garbage int) int { |
| bits := 0 |
| bits ^= 1 << 0 |
| if a { |
| bits ^= 1 << 1 |
| } |
| bits ^= 1 << 2 |
| if b { |
| bits ^= 1 << 3 |
| } |
| bits ^= 1 << 2 |
| if c { |
| bits ^= 1 << 4 |
| } |
| bits ^= garbage &^ (1<<2 | 1<<0) |
| return bits & (1<<2 | 1<<0) // ERROR "known value of v[0-9]+ \(And64\): 1$" |
| } |
| |
| func unknownBitsXorToggle(a, b, c bool) int { |
| bits := 0 |
| bits ^= 1 << 0 |
| if a { |
| bits ^= 1 << 1 |
| } |
| bits ^= 1 << 2 |
| if b { |
| bits ^= 1 << 2 |
| } |
| bits ^= 1 << 2 |
| if c { |
| bits ^= 1 << 4 |
| } |
| return bits & (1<<2 | 1<<0) |
| } |
| |
| func knownBitsPhiComAnd(cond bool) int { |
| x := 1 |
| if cond { |
| x = 3 |
| } |
| return ^x & 1 // ERROR "known value of v[0-9]+ \(And64\): 0$" |
| } |
| |
| func knownBitsPhiComAndGarbage(cond bool, garbage int) int { |
| x := 1 |
| if cond { |
| x = 3 |
| } |
| x ^= garbage &^ 1 |
| return ^x & 1 // ERROR "known value of v[0-9]+ \(And64\): 0$" |
| } |
| |
| func unknownBitsPhiComAnd(cond bool) int { |
| x := 1 |
| if cond { |
| x = 2 |
| } |
| return ^x & 1 |
| } |
| |
| func knownBitsEqFalse(x, y uint64) bool { |
| x |= 1 |
| y &^= 1 |
| return x == y // ERROR "known value of v[0-9]+ \(Eq64\): false$" |
| } |
| |
| func knownBitsEqTrue(x uint64, cond bool) bool { |
| x |= (1<<32 - 1) << 32 |
| if cond { |
| x |= 42 |
| } |
| x |= 1<<32 - 1 // ERROR "known value of v[0-9]+ \(Or64\): -1$" |
| return x == 1<<64-1 // ERROR "known value of v[0-9]+ \(Eq64\): true$" |
| } |
| |
| func unknownBitsEq(x, y uint64) bool { |
| x |= 1 |
| return x == y |
| } |
| |
| func knownBitsNeqTrue(x, y uint64) bool { |
| x |= 1 |
| y &^= 1 |
| return x != y // ERROR "known value of v[0-9]+ \(Neq64\): true$" |
| } |
| |
| func knownBitsNeqFalse(x uint64, cond bool) bool { |
| x |= (1<<32 - 1) << 32 |
| if cond { |
| x |= 42 |
| } |
| x |= 1<<32 - 1 |
| return x != 1<<64-1 // ERROR "known value of v[0-9]+ \(Neq64\): false$" |
| } |
| |
| func unknownBitsNeq(x, y uint64) bool { |
| x |= 1 |
| return x != y |
| } |
| |
| func knownBitsZeroExtPassThrough(x uint8) uint64 { |
| x |= 6 |
| return uint64(x) & 6 // ERROR "known value of v[0-9]+ \(And64\): 6$" |
| } |
| |
| func knownBitsZeroExtUpperHalf(x uint16) uint32 { |
| return uint32(x) & 0xFFFF0000 // ERROR "known value of v[0-9]+ \(And32\): 0$" |
| } |
| |
| func unknownBitsZeroExt(x uint16) uint32 { |
| x |= 0xAAAA |
| return uint32(x) & 0xFFFFF000 |
| } |
| |
| func cvtBoolToUint8(cond bool) (r uint8) { |
| if cond { |
| r = 1 |
| } |
| return r |
| } |
| |
| func knownBitsCvtBoolToUint8False(x, y uint64) uint8 { |
| x |= 1 |
| y &^= 1 |
| bool := x == y // ERROR "known value of v[0-9]+ \(Eq64\): false$" |
| return cvtBoolToUint8(bool) & 1 // ERROR "known value of v[0-9]+ \(CvtBoolToUint8\): 0$" |
| } |
| |
| func knownBitsCvtBoolToUint8True(x int64, cond bool) uint8 { |
| x |= 6 |
| if cond { |
| x |= 1 |
| x |= 4 |
| } |
| // I would expect "known value of v[0-9]+ \(And64\): 6$" to be required, but somehow it's not there even tho the AND is being folded. |
| // I think it's an issue with the And's LOC meaning known bits prints it without a LOC and errorcheck skips it. |
| r := cvtBoolToUint8(x&6 == 6) // ERROR "known value of v[0-9]+ \(Eq64\): true$" "known value of v[0-9]+ \(CvtBoolToUint8\): 1$" |
| if cond { |
| r |= 4 // ERROR "known value of v[0-9]+ \(Or8\): 5$" |
| } |
| return r & 3 // ERROR "known value of v[0-9]+ \(And8\): 1$" |
| } |
| |
| func unknownBitsCvtBoolToUint8(cond bool) uint8 { |
| return cvtBoolToUint8(cond) & 1 |
| } |
| |
| func knownBitsSignExtPassThrough(x int8) int64 { |
| x |= 6 |
| return int64(x) & 6 // ERROR "known value of v[0-9]+ \(And64\): 6$" |
| } |
| |
| func knownBitsSignExtUpperHalf(x int16) int32 { |
| x |= -1 << 15 |
| return int32(x) & (-1 << 16) // ERROR "known value of v[0-9]+ \(And32\): -65536$" |
| } |
| |
| func unknownBitsSignExt(x int16) int32 { |
| x |= -0b010101010101010 |
| return int32(x) & -1 << 12 |
| } |
| |
| func knownBitsLsh(x, y uint32) uint32 { |
| x |= 0b11110 |
| x &^= 0b100000 |
| y &= 2 |
| |
| // ???01111? |
| // ?01111??? |
| // --------- |
| // ????11??? |
| |
| return (x << y) & 0b11000 // ERROR "known value of v[0-9]+ \(And32\): 24$" |
| } |
| |
| func knownBitsLshZero(x, y uint64) uint64 { |
| x &^= 2 |
| y &^= 2 |
| y |= 128 |
| |
| return (x << y) & 8 // ERROR "known value of v[0-9]+ \(And64\): 0$" "known value of v[0-9]+ \(Lsh64x[0-9]+\): 0$" |
| } |
| |
| func unknownBitsLshLeftSideMsb(x uint32, y uint32) uint32 { |
| x |= 0b11110 |
| x &^= 0b100000 |
| y &= 2 |
| |
| return (x << y) & 0b111000 |
| } |
| |
| func unknownBitsLshLeftSideLsb(x uint32, y uint32) uint32 { |
| x |= 0b11110 |
| x &^= 0b100000 |
| y &= 2 |
| |
| return (x << y) & 0b011100 |
| } |
| |
| func unknownBitsLshRightSide(x uint32, y uint32) uint32 { |
| x |= 0b11110 |
| x &^= 0b100000 |
| y &= 6 |
| |
| return (x << y) & 0b11000 |
| } |
| |
| func knownBitsRshU(x, y uint32) uint32 { |
| x |= 0b11110 |
| x &^= 0b100000 |
| y &= 2 |
| |
| // ?01111? |
| // ???0111 |
| // ------- |
| // ????11? |
| |
| return (x >> y) & 0b110 // ERROR "known value of v[0-9]+ \(And32\): 6$" |
| } |
| |
| func knownBitsRshUZero(x, y uint64) uint64 { |
| x &^= 4 |
| y &^= 2 |
| y |= 128 |
| |
| return (x >> y) & 1 // ERROR "known value of v[0-9]+ \(And64\): 0$" "known value of v[0-9]+ \(Rsh64Ux[0-9]+\): 0$" |
| } |
| |
| func unknownBitsRshULeftSideMsb(x uint32, y uint32) uint32 { |
| x |= 0b11110 |
| x &^= 0b100000 |
| y &= 2 |
| |
| return (x >> y) & 0b1110 |
| } |
| |
| func unknownBitsRshULeftSideLsb(x uint32, y uint32) uint32 { |
| x |= 0b11110 |
| x &^= 0b100000 |
| y &= 2 |
| |
| return (x >> y) & 0b111 |
| } |
| |
| func unknownBitsRshURightSide(x uint32, y uint32) uint32 { |
| x |= 0b11110 |
| x &^= 0b100000 |
| y &= 6 |
| |
| return (x >> y) & 0b110 |
| } |
| |
| func knownBitsRsh(x, y int32) int32 { |
| x |= 0b11110 |
| x &^= 0b100000 |
| y &= 2 |
| |
| // ?01111? |
| // ???0111 |
| // ------- |
| // ????11? |
| |
| return (x >> y) & 0b110 // ERROR "known value of v[0-9]+ \(And32\): 6$" |
| } |
| |
| func knownBitsRshSignCopy(x, y int64) int64 { |
| x |= -1 << 63 |
| y |= 128 |
| |
| return (x >> y) & 1 // ERROR "known value of v[0-9]+ \(And64\): 1$" |
| } |
| |
| func unknownBitsRshLeftSideMsb(x int32, y int32) int32 { |
| x |= 0b11110 |
| x &^= 0b100000 |
| y &= 2 |
| |
| return (x >> y) & 0b1110 |
| } |
| |
| func unknownBitsRshLeftSideLsb(x int32, y int32) int32 { |
| x |= 0b11110 |
| x &^= 0b100000 |
| y &= 2 |
| |
| return (x >> y) & 0b111 |
| } |
| |
| func unknownBitsRshRightSide(x int32, y int32) int32 { |
| x |= 0b11110 |
| x &^= 0b100000 |
| y &= 6 |
| |
| return (x >> y) & 0b110 |
| } |
| |
| func knownBitsTrunc(x int64, cond bool) int32 { |
| x |= 2 |
| if cond { |
| x = 3 |
| } |
| |
| return int32(x) & 2 // ERROR "known value of v[0-9]+ \(And32\): 2$" |
| } |
| |
| func unknownBitsTrunc(x int64, cond bool) int32 { |
| x |= 2 |
| if cond { |
| x = 3 |
| } |
| |
| return int32(x) & 1 |
| } |
| |
| func knownBitsSextAfterTrunc(x int64, cond1, cond2 bool) int64 { |
| x |= -1 << 31 |
| if cond1 { |
| x = -3 |
| } |
| |
| truncated := int32(x) |
| |
| if cond2 { |
| truncated |= 4 |
| } |
| |
| return int64(truncated) & (-1 << 63) // ERROR "known value of v[0-9]+ \(And64\): -9223372036854775808$" |
| } |
| |
| func unknownBitsSextAfterTrunc(x int64, cond1, cond2 bool) int64 { |
| x |= 2 |
| if cond1 { |
| x = 3 |
| } |
| |
| truncated := int32(x) |
| |
| if cond2 { |
| truncated |= 4 |
| } |
| |
| return int64(truncated) & (-1 << 63) |
| } |
