diff --git a/lang/check/bounds.go b/lang/check/bounds.go index b5456383..261d2f7d 100644 --- a/lang/check/bounds.go +++ b/lang/check/bounds.go @@ -48,6 +48,29 @@ func neg(i *big.Int) *big.Int { return big.NewInt(0).Neg(i) } +func roundUpToPowerOf2Minus1(i *big.Int) *big.Int { + if i.Cmp(zero) < 0 { + panic("unreachable") + } + bitLen := i.BitLen() + switch bitLen { + case 0: + return zero + case 1: + return one + case 8: + return numTypeBounds[t.KeyU8][1] + case 16: + return numTypeBounds[t.KeyU16][1] + case 32: + return numTypeBounds[t.KeyU32][1] + case 64: + return numTypeBounds[t.KeyU64][1] + } + z := big.NewInt(0).Lsh(one, uint(bitLen)) + return z.Sub(z, one) +} + func invert(m *t.IDMap, n *a.Expr) (*a.Expr, error) { if !n.MType().IsBool() { return nil, fmt.Errorf("check: invert(%q) called on non-bool-typed expression", n.String(m)) @@ -423,9 +446,29 @@ func (q *checker) bcheckExprBinaryOp(lhs *a.Expr, op t.Key, rhs *a.Expr, depth u case t.KeyXBinarySlash: case t.KeyXBinaryShiftL: case t.KeyXBinaryShiftR: - case t.KeyXBinaryAmp: + case t.KeyXBinaryAmp, t.KeyXBinaryPipe: + // TODO: should type-checking ensure that bitwise ops only apply to + // *unsigned* integer types? + if lMin.Cmp(zero) < 0 { + return nil, nil, fmt.Errorf("check: bitwise op argument %q is possibly negative", lhs.String(q.idMap)) + } + if lMax.Cmp(numTypeBounds[t.KeyU64][1]) > 0 { + return nil, nil, fmt.Errorf("check: bitwise op argument %q is possibly too large", lhs.String(q.idMap)) + } + if rMin.Cmp(zero) < 0 { + return nil, nil, fmt.Errorf("check: bitwise op argument %q is possibly negative", rhs.String(q.idMap)) + } + if rMax.Cmp(numTypeBounds[t.KeyU64][1]) > 0 { + return nil, nil, fmt.Errorf("check: bitwise op argument %q is possibly too large", rhs.String(q.idMap)) + } + max := lMax + if max.Cmp(rMax) < 0 { + max = rMax + } + // Round up max to the next-power-of-2-minus-1, and return [0, max]. + // This is conservative, but works fine in practice. + return zero, roundUpToPowerOf2Minus1(max), nil case t.KeyXBinaryAmpHat: - case t.KeyXBinaryPipe: case t.KeyXBinaryHat: case t.KeyXBinaryNotEq, t.KeyXBinaryLessThan, t.KeyXBinaryLessEq, t.KeyXBinaryEqEq, diff --git a/lang/check/check_test.go b/lang/check/check_test.go index b5d3154c..e6dedfa9 100644 --- a/lang/check/check_test.go +++ b/lang/check/check_test.go @@ -224,3 +224,41 @@ func TestConstValues(t *testing.T) { } } } + +func TestRoundUpToPowerOf2Minus1(t *testing.T) { + testCases := [][2]uint64{ + {0, 0}, + {1, 1}, + {2, 3}, + {3, 3}, + {4, 7}, + {5, 7}, + {50, 63}, + {500, 511}, + {5000, 8191}, + {50000, 65535}, + {500000, 524287}, + {1<<7 - 2, 1<<7 - 1}, + {1<<7 - 1, 1<<7 - 1}, + {1<<7 + 0, 1<<8 - 1}, + {1<<7 + 1, 1<<8 - 1}, + {1<<8 - 2, 1<<8 - 1}, + {1<<8 - 1, 1<<8 - 1}, + {1<<8 + 0, 1<<9 - 1}, + {1<<8 + 1, 1<<9 - 1}, + {1<<32 - 2, 1<<32 - 1}, + {1<<32 - 1, 1<<32 - 1}, + {1<<32 + 0, 1<<33 - 1}, + {1<<32 + 1, 1<<33 - 1}, + {1<<64 - 2, 1<<64 - 1}, + {1<<64 - 1, 1<<64 - 1}, + } + + for _, tc := range testCases { + got := roundUpToPowerOf2Minus1(big.NewInt(0).SetUint64(tc[0])) + want := big.NewInt(0).SetUint64(tc[1]) + if got.Cmp(want) != 0 { + t.Errorf("roundUpToPowerOf2Minus1(%v): got %v, want %v", tc[0], got, tc[1]) + } + } +} diff --git a/std/gif/decode_lzw.puffs b/std/gif/decode_lzw.puffs index bb82a820..4cfa07d8 100644 --- a/std/gif/decode_lzw.puffs +++ b/std/gif/decode_lzw.puffs @@ -21,7 +21,7 @@ pub func lzw_decoder.decode?(dst ptr io.buf1, src ptr io.buf1, src_final bool)() post n_bits >= width, { assert n_bits < 12 via "a < b: a < c <= b"(c:width) - // TODO. + bits |= 0 // TODO. n_bits += 8 } }