mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-17 16:32:11 +01:00
The LICENSE has changed from a single license (Apache2) to a dual license (Apache2 or MIT, at your option). If you've previously used Wuffs under the Apache2 license, you are able to keep doing so. No further action required by you. The two files listed below (previous releases) are exceptions, as they are older snapshots, frozen in time. Their license has not changed: release/c/wuffs-v0.2.c release/c/wuffs-v0.3.c Every name in the AUTHORS file, other than Google Inc., has signed Google's CLA (Contributor License Agreement).
1896 lines
50 KiB
Go
1896 lines
50 KiB
Go
// Copyright 2017 The Wuffs Authors.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
|
|
package check
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"math/big"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"github.com/google/wuffs/lib/interval"
|
|
|
|
a "github.com/google/wuffs/lang/ast"
|
|
t "github.com/google/wuffs/lang/token"
|
|
)
|
|
|
|
type bounds = interval.IntRange
|
|
|
|
var numShiftBounds = [...]bounds{
|
|
t.IDU8: {zero, big.NewInt(7)},
|
|
t.IDU16: {zero, big.NewInt(15)},
|
|
t.IDU32: {zero, big.NewInt(31)},
|
|
t.IDU64: {zero, big.NewInt(63)},
|
|
}
|
|
|
|
var numTypeBounds = [...]bounds{
|
|
t.IDI8: {big.NewInt(-1 << 7), big.NewInt(1<<7 - 1)},
|
|
t.IDI16: {big.NewInt(-1 << 15), big.NewInt(1<<15 - 1)},
|
|
t.IDI32: {big.NewInt(-1 << 31), big.NewInt(1<<31 - 1)},
|
|
t.IDI64: {big.NewInt(-1 << 63), big.NewInt(1<<63 - 1)},
|
|
t.IDU8: {zero, big.NewInt(0).SetUint64(1<<8 - 1)},
|
|
t.IDU16: {zero, big.NewInt(0).SetUint64(1<<16 - 1)},
|
|
t.IDU32: {zero, big.NewInt(0).SetUint64(1<<32 - 1)},
|
|
t.IDU64: {zero, big.NewInt(0).SetUint64(1<<64 - 1)},
|
|
t.IDBool: {zero, one},
|
|
}
|
|
|
|
var (
|
|
minusOne = big.NewInt(-1)
|
|
zero = big.NewInt(+0)
|
|
one = big.NewInt(+1)
|
|
two = big.NewInt(+2)
|
|
three = big.NewInt(+3)
|
|
four = big.NewInt(+4)
|
|
five = big.NewInt(+5)
|
|
six = big.NewInt(+6)
|
|
seven = big.NewInt(+7)
|
|
eight = big.NewInt(+8)
|
|
sixteen = big.NewInt(+16)
|
|
thirtyTwo = big.NewInt(+32)
|
|
sixtyFour = big.NewInt(+64)
|
|
oneTwentyEight = big.NewInt(+128)
|
|
ffff = big.NewInt(0xFFFF)
|
|
|
|
// maxPointerBounds is the artificial value in the [0 ..= maxPointerBounds]
|
|
// range for bounds-checking pointer-typed values. Its value is arbitrary
|
|
// (but greater than 1).
|
|
//
|
|
// It is positive (not 0) to distinguish nullptr from non-nullptr. More
|
|
// subtly, it is greater than 1 so that two non-nullptr pointer-typed
|
|
// values aren't necessarily equal.
|
|
maxPointerBounds = big.NewInt(1234)
|
|
|
|
// funcBounds is the artificial value in the [1 ..= funcBounds] range for
|
|
// bounds-checking function-typed values. Its value is arbitrary (but
|
|
// greater than 1) for the same reasons as maxPointerBounds.
|
|
funcBounds = big.NewInt(5678)
|
|
|
|
minIdeal = big.NewInt(0).Lsh(minusOne, 1000)
|
|
maxIdeal = big.NewInt(0).Lsh(one, 1000)
|
|
|
|
maxIntBits = big.NewInt(t.MaxIntBits)
|
|
|
|
zeroExpr = a.NewExpr(0, 0, t.ID0, nil, nil, nil, nil)
|
|
)
|
|
|
|
func init() {
|
|
zeroExpr.SetConstValue(zero)
|
|
zeroExpr.SetMBounds(bounds{zero, zero})
|
|
zeroExpr.SetMType(typeExprIdeal)
|
|
}
|
|
|
|
func isErrorStatus(literal t.ID, tm *t.Map) bool {
|
|
s := literal.Str(tm)
|
|
return (len(s) >= 2) && (s[0] == '"') && (s[1] == '#')
|
|
}
|
|
|
|
func btoi(b bool) *big.Int {
|
|
if b {
|
|
return one
|
|
}
|
|
return zero
|
|
}
|
|
|
|
func add1(i *big.Int) *big.Int {
|
|
return big.NewInt(0).Add(i, one)
|
|
}
|
|
|
|
func sub1(i *big.Int) *big.Int {
|
|
return big.NewInt(0).Sub(i, one)
|
|
}
|
|
|
|
func neg(i *big.Int) *big.Int {
|
|
return big.NewInt(0).Neg(i)
|
|
}
|
|
|
|
func min(i, j *big.Int) *big.Int {
|
|
if i.Cmp(j) < 0 {
|
|
return i
|
|
}
|
|
return j
|
|
}
|
|
|
|
func max(i, j *big.Int) *big.Int {
|
|
if i.Cmp(j) > 0 {
|
|
return i
|
|
}
|
|
return j
|
|
}
|
|
|
|
// bitMask returns (1<<nBits - 1) as a big integer.
|
|
func bitMask(nBits int) *big.Int {
|
|
switch nBits {
|
|
case 0:
|
|
return zero
|
|
case 1:
|
|
return one
|
|
case 8:
|
|
return numTypeBounds[t.IDU8][1]
|
|
case 16:
|
|
return numTypeBounds[t.IDU16][1]
|
|
case 32:
|
|
return numTypeBounds[t.IDU32][1]
|
|
case 64:
|
|
return numTypeBounds[t.IDU64][1]
|
|
}
|
|
z := big.NewInt(0).Lsh(one, uint(nBits))
|
|
return z.Sub(z, one)
|
|
}
|
|
|
|
func invert(tm *t.Map, n *a.Expr) (*a.Expr, error) {
|
|
if !n.MType().IsBool() {
|
|
return nil, fmt.Errorf("check: invert(%q) called on non-bool-typed expression", n.Str(tm))
|
|
}
|
|
if cv := n.ConstValue(); cv != nil {
|
|
return nil, fmt.Errorf("check: invert(%q) called on constant expression", n.Str(tm))
|
|
}
|
|
op, lhs, rhs, args := n.Operator(), n.LHS().AsExpr(), n.RHS().AsExpr(), []*a.Node(nil)
|
|
switch op {
|
|
case t.IDXUnaryNot:
|
|
return rhs, nil
|
|
case t.IDXBinaryNotEq:
|
|
op = t.IDXBinaryEqEq
|
|
case t.IDXBinaryLessThan:
|
|
op = t.IDXBinaryGreaterEq
|
|
case t.IDXBinaryLessEq:
|
|
op = t.IDXBinaryGreaterThan
|
|
case t.IDXBinaryEqEq:
|
|
op = t.IDXBinaryNotEq
|
|
case t.IDXBinaryGreaterEq:
|
|
op = t.IDXBinaryLessThan
|
|
case t.IDXBinaryGreaterThan:
|
|
op = t.IDXBinaryLessEq
|
|
case t.IDXBinaryAnd, t.IDXBinaryOr:
|
|
var err error
|
|
lhs, err = invert(tm, lhs)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
rhs, err = invert(tm, rhs)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if op == t.IDXBinaryAnd {
|
|
op = t.IDXBinaryOr
|
|
} else {
|
|
op = t.IDXBinaryAnd
|
|
}
|
|
case t.IDXAssociativeAnd, t.IDXAssociativeOr:
|
|
args = make([]*a.Node, 0, len(n.Args()))
|
|
for _, a := range n.Args() {
|
|
v, err := invert(tm, a.AsExpr())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
args = append(args, v.AsNode())
|
|
}
|
|
if op == t.IDXAssociativeAnd {
|
|
op = t.IDXAssociativeOr
|
|
} else {
|
|
op = t.IDXAssociativeAnd
|
|
}
|
|
default:
|
|
op, lhs, rhs = t.IDXUnaryNot, nil, n
|
|
}
|
|
o := a.NewExpr(n.AsNode().AsRaw().Flags(), op, 0, lhs.AsNode(), nil, rhs.AsNode(), args)
|
|
o.SetMType(n.MType())
|
|
return o, nil
|
|
}
|
|
|
|
func updateFactsForSuspension(x *a.Expr) (*a.Expr, error) {
|
|
if x.Mentions(exprArgs) || x.Mentions(exprThis) {
|
|
return nil, nil
|
|
}
|
|
// TODO: drop any facts involving ptr-typed local variables?
|
|
return x, nil
|
|
}
|
|
|
|
func (q *checker) bcheckBlock(block []*a.Node) error {
|
|
unreachable := false
|
|
for _, o := range block {
|
|
q.errFilename, q.errLine = o.AsRaw().FilenameLine()
|
|
if unreachable {
|
|
return fmt.Errorf("check: unreachable code")
|
|
}
|
|
if err := q.bcheckStatement(o); err != nil {
|
|
return err
|
|
}
|
|
|
|
switch o.Kind() {
|
|
default:
|
|
continue
|
|
case a.KJump:
|
|
// No-op.
|
|
case a.KRet:
|
|
if o.AsRet().Keyword() == t.IDYield {
|
|
if err := q.facts.update(updateFactsForSuspension); err != nil {
|
|
return err
|
|
}
|
|
continue
|
|
}
|
|
}
|
|
unreachable = true
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (q *checker) bcheckStatement(n *a.Node) error {
|
|
switch n.Kind() {
|
|
case a.KAssert:
|
|
if err := q.bcheckAssert(n.AsAssert()); err != nil {
|
|
return err
|
|
}
|
|
|
|
case a.KAssign:
|
|
n := n.AsAssign()
|
|
if err := q.bcheckAssignment(n.LHS(), n.Operator(), n.RHS()); err != nil {
|
|
return err
|
|
}
|
|
|
|
case a.KChoose:
|
|
// No-op.
|
|
|
|
case a.KIOManip:
|
|
n := n.AsIOManip()
|
|
if _, err := q.bcheckExpr(n.IO(), 0); err != nil {
|
|
return err
|
|
}
|
|
if _, err := q.bcheckExpr(n.Arg1(), 0); err != nil {
|
|
return err
|
|
}
|
|
if histPos := n.HistoryPosition(); histPos != nil {
|
|
if _, err := q.bcheckExpr(histPos, 0); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if err := q.bcheckBlock(n.Body()); err != nil {
|
|
return err
|
|
}
|
|
// TODO: invalidate any facts regarding the io_bind expressions.
|
|
|
|
case a.KIf:
|
|
if err := q.bcheckIf(n.AsIf()); err != nil {
|
|
return err
|
|
}
|
|
|
|
case a.KIterate:
|
|
n := n.AsIterate()
|
|
if _, err := q.bcheckExpr(n.UnrollAsExpr(), 0); err != nil {
|
|
return err
|
|
}
|
|
for _, o := range n.Assigns() {
|
|
o := o.AsAssign()
|
|
if err := q.bcheckAssignment(o.LHS(), o.Operator(), o.RHS()); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
// TODO: this isn't right, as the body is a loop, not an
|
|
// execute-exactly-once block. We should have pre / inv / post
|
|
// conditions, a la bcheckWhile.
|
|
|
|
assigns := n.Assigns()
|
|
for ; n != nil; n = n.ElseIterate() {
|
|
if _, err := q.bcheckExpr(n.UnrollAsExpr(), 0); err != nil {
|
|
return err
|
|
}
|
|
q.facts = q.facts[:0]
|
|
for _, o := range assigns {
|
|
lhs := o.AsAssign().LHS()
|
|
lhsExpr := a.NewExpr(0, 0, lhs.Ident(), nil, nil, nil, nil)
|
|
lhsExpr.SetMType(lhs.MType())
|
|
q.facts = append(q.facts, q.makeSliceLengthEqEq(lhsExpr, n.Length()))
|
|
}
|
|
if err := q.bcheckBlock(n.Body()); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
q.facts = q.facts[:0]
|
|
|
|
case a.KJump:
|
|
n := n.AsJump()
|
|
skip := t.IDPost
|
|
if n.Keyword() == t.IDBreak {
|
|
skip = t.IDPre
|
|
}
|
|
for _, o := range n.JumpTarget().Asserts() {
|
|
if o.AsAssert().Keyword() == skip {
|
|
continue
|
|
}
|
|
if err := q.bcheckAssert(o.AsAssert()); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
q.facts = q.facts[:0]
|
|
|
|
case a.KRet:
|
|
n := n.AsRet()
|
|
lTyp := q.astFunc.Out()
|
|
if q.astFunc.Effect().Coroutine() {
|
|
lTyp = typeExprStatus
|
|
} else if lTyp == nil {
|
|
lTyp = typeExprEmptyStruct
|
|
}
|
|
if _, err := q.bcheckAssignment1(nil, lTyp, t.IDEq, n.Value()); err != nil {
|
|
return err
|
|
}
|
|
|
|
if lTyp.IsStatus() {
|
|
if v := n.Value(); (v.Operator() == 0) || (v.Operator() == a.ExprOperatorSelector) {
|
|
if id := v.Ident(); (id != t.IDOk) && (q.hasIsErrorFact(id) || isErrorStatus(id, q.tm)) {
|
|
n.SetRetsError()
|
|
}
|
|
}
|
|
}
|
|
|
|
case a.KVar:
|
|
if err := q.bcheckVar(n.AsVar()); err != nil {
|
|
return err
|
|
}
|
|
|
|
case a.KWhile:
|
|
if err := q.bcheckWhile(n.AsWhile()); err != nil {
|
|
return err
|
|
}
|
|
|
|
default:
|
|
return fmt.Errorf("check: unrecognized ast.Kind (%s) for bcheckStatement", n.Kind())
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (q *checker) hasIsErrorFact(id t.ID) bool {
|
|
for _, x := range q.facts {
|
|
if lhs, meth, args, _ := x.IsMethodCall(); (meth != t.IDIsError) || (len(args) != 0) ||
|
|
(lhs.Operator() != 0) || (lhs.Ident() != id) {
|
|
continue
|
|
}
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (q *checker) bcheckFuncAssert(n *a.Assert) error {
|
|
if n.IsChooseCPUArch() {
|
|
b := bounds{zero, one}
|
|
cond := n.Condition()
|
|
cond.SetMBounds(b)
|
|
cond.LHS().AsExpr().SetMBounds(b)
|
|
cond.RHS().AsExpr().SetMBounds(b)
|
|
return nil
|
|
}
|
|
return fmt.Errorf("check: function assertions are not supported yet")
|
|
}
|
|
|
|
func (q *checker) bcheckAssert(n *a.Assert) error {
|
|
if err := n.DropExprCachedMBounds(); err != nil {
|
|
return err
|
|
}
|
|
|
|
condition := n.Condition()
|
|
if _, err := q.bcheckExpr(condition, 0); err != nil {
|
|
return err
|
|
}
|
|
for _, o := range n.Args() {
|
|
if _, err := q.bcheckExpr(o.AsArg().Value(), 0); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
for _, x := range q.facts {
|
|
if x.Eq(condition) {
|
|
return nil
|
|
}
|
|
}
|
|
err := errFailed
|
|
|
|
if cv := condition.ConstValue(); cv != nil {
|
|
if cv.Cmp(one) == 0 {
|
|
err = nil
|
|
}
|
|
} else if reasonID := n.Reason(); reasonID != 0 {
|
|
if reasonFunc := q.reasonMap[reasonID]; reasonFunc != nil {
|
|
err = reasonFunc(q, n)
|
|
} else {
|
|
err = fmt.Errorf("check: no such reason %s", reasonID.Str(q.tm))
|
|
}
|
|
} else if condition.Operator().IsBinaryOp() && condition.Operator() != t.IDAs {
|
|
err = q.proveBinaryOp(condition.Operator(),
|
|
condition.LHS().AsExpr(), condition.RHS().AsExpr())
|
|
}
|
|
|
|
if err != nil {
|
|
if err == errFailed {
|
|
return fmt.Errorf("check: cannot prove %q", condition.Str(q.tm))
|
|
}
|
|
return fmt.Errorf("check: cannot prove %q: %v", condition.Str(q.tm), err)
|
|
}
|
|
o, err := simplify(q.tm, condition)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
q.facts.appendFact(o)
|
|
return nil
|
|
}
|
|
|
|
func (q *checker) bcheckAssignment(lhs *a.Expr, op t.ID, rhs *a.Expr) error {
|
|
oldFacts := (map[*a.Expr]struct{})(nil)
|
|
if (rhs.Operator() == a.ExprOperatorCall) && rhs.Effect().Impure() {
|
|
oldFacts = map[*a.Expr]struct{}{}
|
|
for _, x := range q.facts {
|
|
oldFacts[x] = struct{}{}
|
|
}
|
|
}
|
|
|
|
lTyp := (*a.TypeExpr)(nil)
|
|
if lhs != nil {
|
|
if _, err := q.bcheckExpr(lhs, 0); err != nil {
|
|
return err
|
|
}
|
|
lTyp = lhs.MType()
|
|
}
|
|
|
|
nb, err := q.bcheckAssignment1(lhs, lTyp, op, rhs)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if (rhs.Operator() == a.ExprOperatorCall) && rhs.Effect().Impure() {
|
|
if rhs.Effect().Coroutine() && (op != t.IDEqQuestion) {
|
|
if err := q.facts.update(updateFactsForSuspension); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
recv := rhs.LHS().AsExpr().LHS().AsExpr()
|
|
if err := q.facts.update(func(x *a.Expr) (*a.Expr, error) {
|
|
if _, ok := oldFacts[x]; !ok {
|
|
// No-op. Don't drop any newly minted facts.
|
|
} else {
|
|
// Drop any old facts involving the receiver.
|
|
if x.Mentions(recv) {
|
|
return nil, nil
|
|
}
|
|
// Drop any facts involving a pass-by-reference argument.
|
|
for _, arg := range rhs.Args() {
|
|
v := arg.AsArg().Value()
|
|
if typ := v.MType(); typ.IsBool() || typ.IsNullptr() ||
|
|
typ.IsNumTypeOrIdeal() || typ.IsStatus() {
|
|
continue
|
|
}
|
|
// TODO: take extra care if v is a slice? For example,
|
|
// facts involving "v.length()" aren't affected by passing
|
|
// v to an impure function.
|
|
if x.Mentions(v) {
|
|
return nil, nil
|
|
}
|
|
}
|
|
}
|
|
return x, nil
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if lhs == nil {
|
|
return nil
|
|
}
|
|
|
|
if op == t.IDEq {
|
|
// Drop any facts involving lhs.
|
|
if err := q.facts.update(func(x *a.Expr) (*a.Expr, error) {
|
|
if x.Mentions(lhs) {
|
|
return nil, nil
|
|
}
|
|
return x, nil
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
|
|
if !rhs.Effect().Pure() {
|
|
// No-op.
|
|
|
|
} else if lhs.MType().IsNumType() {
|
|
q.facts.appendBinaryOpFact(t.IDXBinaryEqEq, lhs, rhs)
|
|
|
|
if rhs.Operator() == a.ExprOperatorCall {
|
|
if lTyp := rhs.LHS().AsExpr().MType(); lTyp.IsFuncType() && lTyp.Receiver().IsNumType() {
|
|
switch fn := lTyp.FuncName(); fn {
|
|
case t.IDMax, t.IDMin:
|
|
if err := q.bcheckAssignmentMaxMin(lhs, fn, rhs); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
} else if lhs.MType().IsPointerType() {
|
|
if cv := rhs.ConstValue(); (cv != nil) && (cv.Sign() == 0) {
|
|
q.facts.appendBinaryOpFact(t.IDXBinaryEqEq, lhs, exprNullptr)
|
|
} else {
|
|
q.facts.appendBinaryOpFact(t.IDXBinaryEqEq, lhs, rhs)
|
|
if (lhs.MType().Decorator() == t.IDNptr) && (rhs.MType().Decorator() == t.IDPtr) {
|
|
q.facts.appendBinaryOpFact(t.IDXBinaryNotEq, lhs, exprNullptr)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Look for "lhs = x[i .. j]" where i and j are constants.
|
|
if _, i, j, ok := rhs.IsSlice(); ok {
|
|
icv := (*big.Int)(nil)
|
|
if i == nil {
|
|
icv = zero
|
|
} else if i.ConstValue() != nil {
|
|
icv = i.ConstValue()
|
|
}
|
|
|
|
jcv := (*big.Int)(nil)
|
|
if (j != nil) && (j.ConstValue() != nil) {
|
|
jcv = j.ConstValue()
|
|
}
|
|
|
|
if (icv != nil) && (jcv != nil) {
|
|
n := big.NewInt(0).Sub(jcv, icv)
|
|
id, err := q.tm.Insert(n.String())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// TODO: dupe lhs before making a new fact referencing it?
|
|
q.facts = append(q.facts, q.makeSliceLengthEqEq(lhs, id))
|
|
}
|
|
}
|
|
|
|
} else {
|
|
// Update any facts involving lhs.
|
|
if err := q.facts.update(func(x *a.Expr) (*a.Expr, error) {
|
|
xOp, xLHS, xRHS := parseBinaryOp(x)
|
|
if xOp == 0 || !xLHS.Eq(lhs) {
|
|
if x.Mentions(lhs) {
|
|
return nil, nil
|
|
}
|
|
return x, nil
|
|
}
|
|
if xRHS.Mentions(lhs) {
|
|
return nil, nil
|
|
}
|
|
switch op {
|
|
case t.IDPlusEq, t.IDMinusEq:
|
|
oRHS := a.NewExpr(0, op.BinaryForm(), 0, xRHS.AsNode(), nil, rhs.AsNode(), nil)
|
|
// TODO: call SetMBounds?
|
|
oRHS.SetMType(typeExprIdeal)
|
|
oRHS, err := simplify(q.tm, oRHS)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
o := a.NewExpr(0, xOp, 0, xLHS.AsNode(), nil, oRHS.AsNode(), nil)
|
|
o.SetMBounds(bounds{zero, one})
|
|
o.SetMType(typeExprBool)
|
|
return o, nil
|
|
}
|
|
return nil, nil
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if lhs.MType().IsNumType() && ((op != t.IDEq) || (rhs.ConstValue() == nil)) {
|
|
lb, err := q.bcheckTypeExpr(lhs.MType())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if lb[0].Cmp(nb[0]) < 0 {
|
|
c, err := makeConstValueExpr(q.tm, nb[0])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
q.facts.appendBinaryOpFact(t.IDXBinaryGreaterEq, lhs, c)
|
|
}
|
|
if lb[1].Cmp(nb[1]) > 0 {
|
|
c, err := makeConstValueExpr(q.tm, nb[1])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
q.facts.appendBinaryOpFact(t.IDXBinaryLessEq, lhs, c)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (q *checker) bcheckAssignment1(lhs *a.Expr, lTyp *a.TypeExpr, op t.ID, rhs *a.Expr) (bounds, error) {
|
|
if lhs == nil && op != t.IDEq {
|
|
return bounds{}, fmt.Errorf("check: internal error: missing LHS for op key 0x%X", op)
|
|
}
|
|
|
|
lb, err := bounds{}, (error)(nil)
|
|
if lTyp != nil {
|
|
lb, err = q.bcheckTypeExpr(lTyp)
|
|
if err != nil {
|
|
return bounds{}, err
|
|
}
|
|
}
|
|
|
|
rb := bounds{}
|
|
if op == t.IDEq || op == t.IDEqQuestion {
|
|
rb, err = q.bcheckExpr(rhs, 0)
|
|
} else {
|
|
rb, err = q.bcheckExprBinaryOp(op.BinaryForm(), lhs, rhs, 0)
|
|
}
|
|
if err != nil {
|
|
return bounds{}, err
|
|
}
|
|
|
|
if (lTyp != nil) && ((rb[0].Cmp(lb[0]) < 0) || (rb[1].Cmp(lb[1]) > 0)) {
|
|
if op == t.IDEq {
|
|
return bounds{}, fmt.Errorf("check: expression %q bounds %v is not within bounds %v",
|
|
rhs.Str(q.tm), rb, lb)
|
|
} else {
|
|
return bounds{}, fmt.Errorf("check: assignment %q bounds %v is not within bounds %v",
|
|
lhs.Str(q.tm)+" "+op.Str(q.tm)+" "+rhs.Str(q.tm), rb, lb)
|
|
}
|
|
}
|
|
return rb, nil
|
|
}
|
|
|
|
func (q *checker) bcheckAssignmentMaxMin(lhs *a.Expr, funcName t.ID, rhs *a.Expr) error {
|
|
if len(rhs.Args()) != 1 {
|
|
return fmt.Errorf("check: internal error: max/min has unexpected arguments")
|
|
}
|
|
op := t.ID(0)
|
|
switch funcName {
|
|
case t.IDMax:
|
|
op = t.IDXBinaryGreaterEq
|
|
case t.IDMin:
|
|
op = t.IDXBinaryLessEq
|
|
default:
|
|
return fmt.Errorf("check: internal error: max/min has unexpected function name")
|
|
}
|
|
|
|
operands := [2]*a.Expr{
|
|
rhs.LHS().AsExpr().LHS().AsExpr(),
|
|
rhs.Args()[0].AsArg().Value(),
|
|
}
|
|
for _, operand := range operands {
|
|
if operand.Mentions(lhs) {
|
|
continue
|
|
}
|
|
o := a.NewExpr(0, op, 0, lhs.AsNode(), nil, operand.AsNode(), nil)
|
|
o.SetMBounds(bounds{zero, one})
|
|
o.SetMType(typeExprBool)
|
|
q.facts.appendFact(o)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func snapshot(facts []*a.Expr) []*a.Expr {
|
|
return append([]*a.Expr(nil), facts...)
|
|
}
|
|
|
|
func (q *checker) unify(branches [][]*a.Expr) error {
|
|
q.facts = q.facts[:0]
|
|
if len(branches) == 0 {
|
|
return nil
|
|
}
|
|
q.facts = append(q.facts[:0], branches[0]...)
|
|
if len(branches) == 1 {
|
|
return nil
|
|
}
|
|
if len(branches) > 10000 {
|
|
return fmt.Errorf("check: too many if-else branches")
|
|
}
|
|
|
|
m := map[string]int{}
|
|
for _, b := range branches {
|
|
for _, f := range b {
|
|
m[f.Str(q.tm)]++
|
|
}
|
|
}
|
|
|
|
return q.facts.update(func(n *a.Expr) (*a.Expr, error) {
|
|
if m[n.Str(q.tm)] == len(branches) {
|
|
return n, nil
|
|
}
|
|
return nil, nil
|
|
})
|
|
}
|
|
|
|
func (q *checker) bcheckIf(n *a.If) error {
|
|
branches := [][]*a.Expr(nil)
|
|
for n != nil {
|
|
snap := snapshot(q.facts)
|
|
// Check the if condition.
|
|
if _, err := q.bcheckExpr(n.Condition(), 0); err != nil {
|
|
return err
|
|
}
|
|
|
|
// Check the if-true branch, assuming the if condition.
|
|
if n.Condition().ConstValue() == nil {
|
|
q.facts.appendFact(n.Condition())
|
|
}
|
|
if err := q.bcheckBlock(n.BodyIfTrue()); err != nil {
|
|
return err
|
|
}
|
|
if !a.Terminates(n.BodyIfTrue()) {
|
|
branches = append(branches, snapshot(q.facts))
|
|
}
|
|
|
|
// Check the if-false branch, assuming the inverted if condition.
|
|
q.facts = append(q.facts[:0], snap...)
|
|
if n.Condition().ConstValue() == nil {
|
|
if inverse, err := invert(q.tm, n.Condition()); err != nil {
|
|
return err
|
|
} else {
|
|
q.facts.appendFact(inverse)
|
|
}
|
|
}
|
|
if bif := n.BodyIfFalse(); len(bif) > 0 {
|
|
if err := q.bcheckBlock(bif); err != nil {
|
|
return err
|
|
}
|
|
if !a.Terminates(bif) {
|
|
branches = append(branches, snapshot(q.facts))
|
|
}
|
|
break
|
|
}
|
|
n = n.ElseIf()
|
|
if n == nil {
|
|
branches = append(branches, snapshot(q.facts))
|
|
break
|
|
}
|
|
}
|
|
return q.unify(branches)
|
|
}
|
|
|
|
func (q *checker) bcheckWhile(n *a.While) error {
|
|
// Check the pre and inv conditions on entry.
|
|
for _, o := range n.Asserts() {
|
|
if o.AsAssert().Keyword() == t.IDPost {
|
|
continue
|
|
}
|
|
if err := q.bcheckAssert(o.AsAssert()); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
// Check the while condition.
|
|
if _, err := q.bcheckExpr(n.Condition(), 0); err != nil {
|
|
return err
|
|
}
|
|
|
|
// Check the post conditions on exit, assuming only the pre and inv
|
|
// (invariant) conditions and the inverted while condition.
|
|
//
|
|
// We don't need to check the inv conditions, even though we add them to
|
|
// the facts after the while loop, since we have already proven each inv
|
|
// condition on entry, and below, proven them on each explicit continue and
|
|
// on the implicit continue after the body.
|
|
if cv := n.Condition().ConstValue(); cv != nil && cv.Cmp(one) == 0 {
|
|
// We effectively have a "while true { etc }" loop. There's no need to
|
|
// prove the post conditions here, since we won't ever exit the while
|
|
// loop naturally. We only exit on an explicit break.
|
|
} else {
|
|
q.facts = q.facts[:0]
|
|
for _, o := range n.Asserts() {
|
|
if o.AsAssert().Keyword() == t.IDPost {
|
|
continue
|
|
}
|
|
q.facts.appendFact(o.AsAssert().Condition())
|
|
}
|
|
if inverse, err := invert(q.tm, n.Condition()); err != nil {
|
|
return err
|
|
} else {
|
|
q.facts.appendFact(inverse)
|
|
}
|
|
for _, o := range n.Asserts() {
|
|
if o.AsAssert().Keyword() == t.IDPost {
|
|
if err := q.bcheckAssert(o.AsAssert()); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if cv := n.Condition().ConstValue(); cv != nil && cv.Sign() == 0 {
|
|
// We effectively have a "while false { etc }" loop. There's no need to
|
|
// check the body.
|
|
} else {
|
|
// Assume the pre and inv conditions...
|
|
q.facts = q.facts[:0]
|
|
for _, o := range n.Asserts() {
|
|
if o.AsAssert().Keyword() == t.IDPost {
|
|
continue
|
|
}
|
|
q.facts.appendFact(o.AsAssert().Condition())
|
|
}
|
|
// ...and the while condition, unless it is the redundant "true".
|
|
if cv == nil {
|
|
q.facts.appendFact(n.Condition())
|
|
}
|
|
// Check the body.
|
|
if err := q.bcheckBlock(n.Body()); err != nil {
|
|
return err
|
|
}
|
|
// Check the pre and inv conditions on the implicit continue after the
|
|
// body.
|
|
if !a.Terminates(n.Body()) {
|
|
for _, o := range n.Asserts() {
|
|
if o.AsAssert().Keyword() == t.IDPost {
|
|
continue
|
|
}
|
|
if err := q.bcheckAssert(o.AsAssert()); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Assume the inv and post conditions.
|
|
q.facts = q.facts[:0]
|
|
for _, o := range n.Asserts() {
|
|
if o.AsAssert().Keyword() == t.IDPre {
|
|
continue
|
|
}
|
|
q.facts.appendFact(o.AsAssert().Condition())
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (q *checker) bcheckVar(n *a.Var) error {
|
|
if _, err := q.bcheckTypeExpr(n.XType()); err != nil {
|
|
return err
|
|
}
|
|
|
|
lhs := a.NewExpr(0, 0, n.Name(), nil, nil, nil, nil)
|
|
lhs.SetMType(n.XType())
|
|
// "var x T" has an implicit "= 0".
|
|
//
|
|
// TODO: check that T is an integer type.
|
|
rhs := zeroExpr
|
|
return q.bcheckAssignment(lhs, t.IDEq, rhs)
|
|
}
|
|
|
|
func (q *checker) bcheckExpr(n *a.Expr, depth uint32) (bounds, error) {
|
|
if depth > a.MaxExprDepth {
|
|
return bounds{}, fmt.Errorf("check: expression recursion depth too large")
|
|
}
|
|
depth++
|
|
|
|
if b := n.MBounds(); b[0] != nil {
|
|
return b, nil
|
|
}
|
|
if n.ConstValue() != nil {
|
|
return bcheckExprConstValue(n)
|
|
}
|
|
|
|
nb, err := q.bcheckExpr1(n, depth)
|
|
if err != nil {
|
|
return bounds{}, err
|
|
}
|
|
nb, err = q.facts.refine(n, nb, q.tm)
|
|
if err != nil {
|
|
return bounds{}, err
|
|
}
|
|
tb, err := q.bcheckTypeExpr(n.MType())
|
|
if err != nil {
|
|
return bounds{}, err
|
|
}
|
|
|
|
if (nb[0].Cmp(tb[0]) < 0) || (nb[1].Cmp(tb[1]) > 0) {
|
|
return bounds{}, fmt.Errorf("check: expression %q bounds %v is not within bounds %v",
|
|
n.Str(q.tm), nb, tb)
|
|
}
|
|
|
|
n.SetMBounds(nb)
|
|
return nb, nil
|
|
}
|
|
|
|
func bcheckExprConstValue(n *a.Expr) (bounds, error) {
|
|
if o := n.LHS(); o != nil {
|
|
if _, err := bcheckExprConstValue(o.AsExpr()); err != nil {
|
|
return bounds{}, err
|
|
}
|
|
}
|
|
if o := n.MHS(); o != nil {
|
|
if _, err := bcheckExprConstValue(o.AsExpr()); err != nil {
|
|
return bounds{}, err
|
|
}
|
|
}
|
|
if o := n.RHS(); o != nil && n.Operator() != t.IDXBinaryAs {
|
|
if _, err := bcheckExprConstValue(o.AsExpr()); err != nil {
|
|
return bounds{}, err
|
|
}
|
|
}
|
|
for _, o := range n.Args() {
|
|
if _, err := bcheckExprConstValue(o.AsExpr()); err != nil {
|
|
return bounds{}, err
|
|
}
|
|
}
|
|
cv := n.ConstValue()
|
|
if cv == nil {
|
|
return bounds{}, fmt.Errorf("check: constant expression has nil ConstValue")
|
|
}
|
|
b := bounds{cv, cv}
|
|
n.SetMBounds(b)
|
|
return b, nil
|
|
}
|
|
|
|
func (q *checker) bcheckExpr1(n *a.Expr, depth uint32) (bounds, error) {
|
|
switch op := n.Operator(); {
|
|
case op.IsXUnaryOp():
|
|
return q.bcheckExprUnaryOp(n, depth)
|
|
case op.IsXBinaryOp():
|
|
if op != t.IDXBinaryAs {
|
|
return q.bcheckExprBinaryOp(op, n.LHS().AsExpr(), n.RHS().AsExpr(), depth)
|
|
}
|
|
b, err := q.bcheckExpr(n.LHS().AsExpr(), depth)
|
|
if err != nil {
|
|
return bounds{}, err
|
|
} else if lhs := n.LHS().AsExpr(); lhs.MType().IsEitherSliceType() {
|
|
cv := (*big.Int)(nil)
|
|
rhs := n.RHS().AsTypeExpr()
|
|
if (rhs.Decorator() == t.IDPtr) && (rhs.Inner().IsEitherArrayType()) {
|
|
cv = rhs.Inner().ArrayLength().ConstValue()
|
|
}
|
|
if cv == nil {
|
|
// TODO: fix this.
|
|
return bounds{}, fmt.Errorf("check: cannot bounds-check conversion to %q", rhs.Str(q.tm))
|
|
}
|
|
if err := q.proveSliceLengthAtLeast(lhs, cv); err != nil {
|
|
return bounds{}, err
|
|
}
|
|
b = bounds{one, maxPointerBounds}
|
|
}
|
|
return b, nil
|
|
case op.IsXAssociativeOp():
|
|
return q.bcheckExprAssociativeOp(n, depth)
|
|
}
|
|
|
|
return q.bcheckExprOther(n, depth)
|
|
}
|
|
|
|
func (q *checker) bcheckExprOther(n *a.Expr, depth uint32) (bounds, error) {
|
|
switch n.Operator() {
|
|
case 0:
|
|
// Look for named consts.
|
|
//
|
|
// TODO: look up "foo[i]" const expressions.
|
|
//
|
|
// TODO: allow imported consts, "foo.bar", not just "bar"?
|
|
qid := t.QID{0, n.Ident()}
|
|
if c, ok := q.c.consts[qid]; ok {
|
|
if cv := c.Value().ConstValue(); cv != nil {
|
|
return bounds{cv, cv}, nil
|
|
}
|
|
}
|
|
|
|
case t.IDOpenParen:
|
|
lhs := n.LHS().AsExpr()
|
|
if _, err := q.bcheckExpr(lhs, depth); err != nil {
|
|
return bounds{}, err
|
|
}
|
|
if err := q.bcheckExprCall(n, depth); err != nil {
|
|
return bounds{}, err
|
|
}
|
|
if nb, err := q.bcheckExprCallSpecialCases(n, depth); err == nil {
|
|
return nb, nil
|
|
} else if err != errNotASpecialCase {
|
|
return bounds{}, err
|
|
}
|
|
|
|
case t.IDOpenBracket:
|
|
lhs := n.LHS().AsExpr()
|
|
if _, err := q.bcheckExpr(lhs, depth); err != nil {
|
|
return bounds{}, err
|
|
}
|
|
rhs := n.RHS().AsExpr()
|
|
if _, err := q.bcheckExpr(rhs, depth); err != nil {
|
|
return bounds{}, err
|
|
}
|
|
|
|
lengthExpr := (*a.Expr)(nil)
|
|
if lTyp := lhs.MType(); lTyp.IsEitherArrayType() {
|
|
lengthExpr = lTyp.ArrayLength()
|
|
} else if lTyp.IsPointerType() && lTyp.Inner().IsEitherArrayType() {
|
|
lengthExpr = lTyp.Inner().ArrayLength()
|
|
if lTyp.Decorator() == t.IDPtr {
|
|
// No-op.
|
|
} else if err := q.proveRecvNotEqNullptr(lhs); err != nil {
|
|
return bounds{}, err
|
|
}
|
|
} else {
|
|
lengthExpr = makeSliceLength(lhs)
|
|
}
|
|
|
|
if err := proveReasonRequirement(q, t.IDXBinaryLessEq, zeroExpr, rhs); err != nil {
|
|
return bounds{}, err
|
|
}
|
|
if err := proveReasonRequirementForRHSLength(q, t.IDXBinaryLessThan, rhs, lengthExpr); err != nil {
|
|
return bounds{}, err
|
|
}
|
|
|
|
case t.IDDotDot:
|
|
lhs := n.LHS().AsExpr()
|
|
if _, err := q.bcheckExpr(lhs, depth); err != nil {
|
|
return bounds{}, err
|
|
}
|
|
mhs := n.MHS().AsExpr()
|
|
if mhs != nil {
|
|
if _, err := q.bcheckExpr(mhs, depth); err != nil {
|
|
return bounds{}, err
|
|
}
|
|
}
|
|
rhs := n.RHS().AsExpr()
|
|
if rhs != nil {
|
|
if _, err := q.bcheckExpr(rhs, depth); err != nil {
|
|
return bounds{}, err
|
|
}
|
|
}
|
|
|
|
if mhs == nil && rhs == nil {
|
|
return bounds{zero, zero}, nil
|
|
}
|
|
|
|
lengthExpr := (*a.Expr)(nil)
|
|
if lTyp := lhs.MType(); lTyp.IsEitherArrayType() {
|
|
lengthExpr = lTyp.ArrayLength()
|
|
} else {
|
|
lengthExpr = makeSliceLength(lhs)
|
|
}
|
|
|
|
if mhs == nil {
|
|
mhs = zeroExpr
|
|
}
|
|
if rhs == nil {
|
|
rhs = lengthExpr
|
|
}
|
|
|
|
if mhs != zeroExpr {
|
|
if err := proveReasonRequirement(q, t.IDXBinaryLessEq, zeroExpr, mhs); err != nil {
|
|
return bounds{}, err
|
|
}
|
|
}
|
|
if err := proveReasonRequirement(q, t.IDXBinaryLessEq, mhs, rhs); err != nil {
|
|
return bounds{}, err
|
|
}
|
|
if rhs != lengthExpr {
|
|
if err := proveReasonRequirementForRHSLength(q, t.IDXBinaryLessEq, rhs, lengthExpr); err != nil {
|
|
return bounds{}, err
|
|
}
|
|
}
|
|
|
|
case t.IDDot:
|
|
if _, err := q.bcheckExpr(n.LHS().AsExpr(), depth); err != nil {
|
|
return bounds{}, err
|
|
}
|
|
|
|
// TODO: delete this hack that only matches "args".
|
|
if n.LHS().AsExpr().Ident() == t.IDArgs {
|
|
for _, o := range q.astFunc.In().Fields() {
|
|
o := o.AsField()
|
|
if o.Name() == n.Ident() {
|
|
return q.bcheckTypeExpr(o.XType())
|
|
}
|
|
}
|
|
lTyp := n.LHS().AsExpr().MType()
|
|
return bounds{}, fmt.Errorf("check: no field named %q found in struct type %q for expression %q",
|
|
n.Ident().Str(q.tm), lTyp.QID().Str(q.tm), n.Str(q.tm))
|
|
}
|
|
|
|
case t.IDComma:
|
|
for _, o := range n.Args() {
|
|
if _, err := q.bcheckExpr(o.AsExpr(), depth); err != nil {
|
|
return bounds{}, err
|
|
}
|
|
}
|
|
|
|
default:
|
|
return bounds{}, fmt.Errorf("check: unrecognized token (0x%X) for bcheckExprOther", n.Operator())
|
|
}
|
|
return q.bcheckTypeExpr(n.MType())
|
|
}
|
|
|
|
func (q *checker) bcheckExprCall(n *a.Expr, depth uint32) error {
|
|
// TODO: handle func pre/post conditions.
|
|
lhs := n.LHS().AsExpr()
|
|
f, err := q.c.resolveFunc(lhs.MType())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
inFields := f.In().Fields()
|
|
if len(inFields) != len(n.Args()) {
|
|
return fmt.Errorf("check: %q has %d arguments but %d were given",
|
|
lhs.MType().Str(q.tm), len(inFields), len(n.Args()))
|
|
}
|
|
for i, o := range n.Args() {
|
|
if _, err := q.bcheckAssignment1(nil, inFields[i].AsField().XType(), t.IDEq, o.AsArg().Value()); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
recv := lhs.LHS().AsExpr()
|
|
if recv.MType().Decorator() != t.IDNptr {
|
|
return nil
|
|
}
|
|
return q.proveRecvNotEqNullptr(recv)
|
|
}
|
|
|
|
var errNotASpecialCase = errors.New("not a special case")
|
|
|
|
func (q *checker) bcheckExprCallSpecialCases(n *a.Expr, depth uint32) (bounds, error) {
|
|
lhs := n.LHS().AsExpr()
|
|
recv := lhs.LHS().AsExpr()
|
|
method := lhs.Ident()
|
|
|
|
actualAdvanceIsAlwaysPositive, advance, advanceExpr, update := false, (*big.Int)(nil), (*a.Expr)(nil), false
|
|
|
|
if recvTyp := recv.MType(); recvTyp == nil {
|
|
return bounds{}, errNotASpecialCase
|
|
|
|
} else if recvTyp.IsNumType() {
|
|
// For a numeric type's low_bits, etc. methods. The bound on the output
|
|
// is dependent on bound on the input, similar to dependent types, and
|
|
// isn't expressible in Wuffs' function syntax and type system.
|
|
switch method {
|
|
case t.IDLowBits, t.IDHighBits:
|
|
ab, err := q.bcheckExpr(n.Args()[0].AsArg().Value(), depth)
|
|
if err != nil {
|
|
return bounds{}, err
|
|
}
|
|
return bounds{
|
|
zero,
|
|
bitMask(int(ab[1].Int64())),
|
|
}, nil
|
|
|
|
case t.IDMin, t.IDMax:
|
|
// TODO: lhs has already been bcheck'ed. There should be no
|
|
// need to bcheck lhs.LHS().Expr() twice.
|
|
lb, err := q.bcheckExpr(lhs.LHS().AsExpr(), depth)
|
|
if err != nil {
|
|
return bounds{}, err
|
|
}
|
|
ab, err := q.bcheckExpr(n.Args()[0].AsArg().Value(), depth)
|
|
if err != nil {
|
|
return bounds{}, err
|
|
}
|
|
if method == t.IDMin {
|
|
return bounds{
|
|
min(lb[0], ab[0]),
|
|
min(lb[1], ab[1]),
|
|
}, nil
|
|
} else {
|
|
return bounds{
|
|
max(lb[0], ab[0]),
|
|
max(lb[1], ab[1]),
|
|
}, nil
|
|
}
|
|
}
|
|
|
|
} else if recvTyp.IsIOTokenType() {
|
|
if method == t.IDUndoByte {
|
|
if err := q.canUndoByte(recv); err != nil {
|
|
return bounds{}, err
|
|
}
|
|
|
|
} else if method == t.IDLimitedCopyU32FromHistory8ByteChunksDistance1Fast {
|
|
if err := q.canLimitedCopyU32FromHistoryFast(recv, n.Args(), eight, nil, one); err != nil {
|
|
return bounds{}, err
|
|
}
|
|
|
|
} else if method == t.IDLimitedCopyU32FromHistory8ByteChunksFast {
|
|
if err := q.canLimitedCopyU32FromHistoryFast(recv, n.Args(), eight, eight, nil); err != nil {
|
|
return bounds{}, err
|
|
}
|
|
|
|
} else if method == t.IDLimitedCopyU32FromHistoryFast {
|
|
if err := q.canLimitedCopyU32FromHistoryFast(recv, n.Args(), nil, one, nil); err != nil {
|
|
return bounds{}, err
|
|
}
|
|
|
|
} else if method == t.IDSkipU32Fast {
|
|
args := n.Args()
|
|
if len(args) != 2 {
|
|
return bounds{}, fmt.Errorf("check: internal error: bad skip_fast arguments")
|
|
}
|
|
actual := args[0].AsArg().Value()
|
|
worstCase := args[1].AsArg().Value()
|
|
if actual.Eq(worstCase) {
|
|
// No-op. Proving "x <= x" is trivial.
|
|
} else if err := q.proveBinaryOp(t.IDXBinaryLessEq, actual, worstCase); err == errFailed {
|
|
return bounds{}, fmt.Errorf("check: could not prove skip_fast pre-condition: %s <= %s",
|
|
actual.Str(q.tm), worstCase.Str(q.tm))
|
|
} else if err != nil {
|
|
return bounds{}, err
|
|
}
|
|
if cv := actual.ConstValue(); (cv != nil) && (cv.Sign() > 0) {
|
|
actualAdvanceIsAlwaysPositive = true
|
|
}
|
|
if cv := worstCase.ConstValue(); cv != nil {
|
|
advance, update = cv, true
|
|
} else {
|
|
advanceExpr, update = actual, true
|
|
}
|
|
|
|
} else if method == t.IDPeekU64LEAt {
|
|
args := n.Args()
|
|
if len(args) != 1 {
|
|
return bounds{}, fmt.Errorf("check: internal error: bad peek_u64le_at arguments")
|
|
}
|
|
offset := args[0].AsArg().Value()
|
|
if offset.ConstValue() == nil {
|
|
return bounds{}, fmt.Errorf("check: peek_u64le_at offset is not a constant value")
|
|
}
|
|
advance, update = big.NewInt(8), false
|
|
advance.Add(advance, offset.ConstValue())
|
|
|
|
} else if method >= t.IDPeekU8 {
|
|
if m := method - t.IDPeekU8; m < t.ID(len(ioMethodAdvances)) {
|
|
au := ioMethodAdvances[m]
|
|
advance, update = au.advance, au.update
|
|
}
|
|
}
|
|
|
|
} else if recvTyp.Eq(typeExprSliceU8) {
|
|
if method >= t.IDPeekU8 {
|
|
if m := method - t.IDPeekU8; m < t.ID(len(ioMethodAdvances)) {
|
|
au := ioMethodAdvances[m]
|
|
advance, update = au.advance, au.update
|
|
}
|
|
}
|
|
|
|
} else if recvTyp.IsCPUArchType() {
|
|
if s := method.Str(q.tm); strings.HasPrefix(s, "make_") || strings.HasPrefix(s, "store_") {
|
|
switch {
|
|
case strings.HasSuffix(s, "_slice64"): // 64 bits is 8 bytes.
|
|
advance = eight
|
|
case strings.HasSuffix(s, "_slice128"): // 128 bits is 16 bytes.
|
|
advance = sixteen
|
|
case strings.HasSuffix(s, "_slice256"): // 256 bits is 32 bytes.
|
|
advance = thirtyTwo
|
|
case strings.HasSuffix(s, "_slice512"): // 512 bits is 64 bytes.
|
|
advance = sixtyFour
|
|
case strings.HasSuffix(s, "_slice_u16lex4"): // 4 u16 values is 8 bytes.
|
|
advance = four
|
|
case strings.HasSuffix(s, "_slice_u16lex8"): // 8 u16 values is 16 bytes.
|
|
advance = eight
|
|
case strings.HasSuffix(s, "_slice_u16lex16"): // 16 u16 values is 32 bytes.
|
|
advance = sixteen
|
|
case strings.HasSuffix(s, "_slice_u16lex32"): // 32 u16 values is 64 bytes.
|
|
advance = thirtyTwo
|
|
case strings.Contains(s, "_slice"):
|
|
return bounds{}, fmt.Errorf("check: internal error: unrecognized %s method", s)
|
|
}
|
|
}
|
|
}
|
|
|
|
if (advance != nil) || (advanceExpr != nil) {
|
|
subject := recv
|
|
if recv.MType().IsCPUArchType() {
|
|
subject = n.Args()[0].AsArg().Value()
|
|
}
|
|
if ok, err := q.optimizeIOMethodAdvance(subject, advance, advanceExpr, update); err != nil {
|
|
return bounds{}, err
|
|
} else if !ok {
|
|
adv := ""
|
|
if advance != nil {
|
|
adv = advance.String()
|
|
} else {
|
|
adv = advanceExpr.Str(q.tm)
|
|
}
|
|
return bounds{}, fmt.Errorf("check: could not prove %s pre-condition: %s.length() >= %s",
|
|
method.Str(q.tm), subject.Str(q.tm), adv)
|
|
}
|
|
if actualAdvanceIsAlwaysPositive {
|
|
q.facts = append(q.facts, makeCanUndoByte(recv))
|
|
}
|
|
// TODO: drop other subject-related facts?
|
|
}
|
|
|
|
return bounds{}, errNotASpecialCase
|
|
}
|
|
|
|
func (q *checker) canUndoByte(recv *a.Expr) error {
|
|
for _, x := range q.facts {
|
|
if lhs, meth, args, _ := x.IsMethodCall(); (meth != t.IDCanUndoByte) || (len(args) != 0) ||
|
|
!lhs.Eq(recv) {
|
|
continue
|
|
}
|
|
return q.facts.update(func(o *a.Expr) (*a.Expr, error) {
|
|
if o.Mentions(recv) {
|
|
return nil, nil
|
|
}
|
|
return o, nil
|
|
})
|
|
}
|
|
return fmt.Errorf("check: could not prove %s.can_undo_byte()", recv.Str(q.tm))
|
|
}
|
|
|
|
func (q *checker) canLimitedCopyU32FromHistoryFast(recv *a.Expr, args []*a.Node, adj *big.Int, minDistance *big.Int, exactDistance *big.Int) error {
|
|
// As per cgen's io-private.h, there are three pre-conditions:
|
|
// - (upTo + adj) <= this.length()
|
|
// - either (distance >= minDistance) or (distance == exactDistance),
|
|
// depending on which of minDistance and exactDistance is non-nil.
|
|
// - distance <= this.history_length()
|
|
//
|
|
// adj may be nil, in which case (upTo + adj) is just upTo.
|
|
|
|
if len(args) != 2 {
|
|
return fmt.Errorf("check: internal error: inconsistent limited_copy_u32_from_history_fast arguments")
|
|
}
|
|
upTo := args[0].AsArg().Value()
|
|
distance := args[1].AsArg().Value()
|
|
|
|
// Check "upTo <= this.length()".
|
|
check0:
|
|
for {
|
|
for _, x := range q.facts {
|
|
if x.Operator() != t.IDXBinaryLessEq {
|
|
continue
|
|
}
|
|
|
|
// Check that the LHS is "(upTo + adj) as base.u64".
|
|
lhs := x.LHS().AsExpr()
|
|
if lhs.Operator() != t.IDXBinaryAs {
|
|
continue
|
|
}
|
|
llhs, lrhs := lhs.LHS().AsExpr(), lhs.RHS().AsTypeExpr()
|
|
if !lrhs.Eq(typeExprU64) {
|
|
continue
|
|
}
|
|
if adj == nil {
|
|
if !llhs.Eq(upTo) {
|
|
continue
|
|
}
|
|
} else {
|
|
if (llhs.Operator() != t.IDXBinaryPlus) || !llhs.LHS().AsExpr().Eq(upTo) {
|
|
continue
|
|
} else if cv := llhs.RHS().AsExpr().ConstValue(); (cv == nil) || (cv.Cmp(adj) != 0) {
|
|
continue
|
|
}
|
|
}
|
|
|
|
// Check that the RHS is "recv.length()".
|
|
y, method, yArgs := splitReceiverMethodArgs(x.RHS().AsExpr())
|
|
if method != t.IDLength || len(yArgs) != 0 {
|
|
continue
|
|
}
|
|
if !y.Eq(recv) {
|
|
continue
|
|
}
|
|
|
|
break check0
|
|
}
|
|
if adj == nil {
|
|
return fmt.Errorf("check: could not prove (%s as base.u64) <= %s.length()",
|
|
upTo.Str(q.tm), recv.Str(q.tm))
|
|
}
|
|
return fmt.Errorf("check: could not prove ((%s + %v) as base.u64) <= %s.length()",
|
|
upTo.Str(q.tm), adj, recv.Str(q.tm))
|
|
}
|
|
|
|
// Check "distance >= minDistance".
|
|
check1a:
|
|
for minDistance != nil {
|
|
for _, x := range q.facts {
|
|
if x.Operator() != t.IDXBinaryGreaterEq {
|
|
continue
|
|
}
|
|
if lhs := x.LHS().AsExpr(); !lhs.Eq(distance) {
|
|
continue
|
|
}
|
|
if rcv := x.RHS().AsExpr().ConstValue(); (rcv == nil) || (rcv.Cmp(minDistance) < 0) {
|
|
continue
|
|
}
|
|
break check1a
|
|
}
|
|
return fmt.Errorf("check: could not prove %s >= %v", distance.Str(q.tm), minDistance)
|
|
}
|
|
|
|
// Check "distance == exactDistance".
|
|
check1b:
|
|
for exactDistance != nil {
|
|
for _, x := range q.facts {
|
|
if x.Operator() != t.IDXBinaryEqEq {
|
|
continue
|
|
}
|
|
if lhs := x.LHS().AsExpr(); !lhs.Eq(distance) {
|
|
continue
|
|
}
|
|
if rcv := x.RHS().AsExpr().ConstValue(); (rcv == nil) || (rcv.Cmp(exactDistance) != 0) {
|
|
continue
|
|
}
|
|
break check1b
|
|
}
|
|
return fmt.Errorf("check: could not prove %s == %v", distance.Str(q.tm), exactDistance)
|
|
}
|
|
|
|
// Check "distance <= this.history_length()".
|
|
check2:
|
|
for {
|
|
for _, x := range q.facts {
|
|
if x.Operator() != t.IDXBinaryLessEq {
|
|
continue
|
|
}
|
|
|
|
// Check that the LHS is "distance as base.u64".
|
|
lhs := x.LHS().AsExpr()
|
|
if lhs.Operator() != t.IDXBinaryAs {
|
|
continue
|
|
}
|
|
llhs, lrhs := lhs.LHS().AsExpr(), lhs.RHS().AsTypeExpr()
|
|
if !llhs.Eq(distance) || !lrhs.Eq(typeExprU64) {
|
|
continue
|
|
}
|
|
|
|
// Check that the RHS is "recv.history_length()".
|
|
y, method, yArgs := splitReceiverMethodArgs(x.RHS().AsExpr())
|
|
if method != t.IDHistoryLength || len(yArgs) != 0 {
|
|
continue
|
|
}
|
|
if !y.Eq(recv) {
|
|
continue
|
|
}
|
|
|
|
break check2
|
|
}
|
|
return fmt.Errorf("check: could not prove %s <= %s.history_length()",
|
|
distance.Str(q.tm), recv.Str(q.tm))
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
var ioMethodAdvances = [...]struct {
|
|
advance *big.Int
|
|
update bool
|
|
}{
|
|
t.IDPeekU8 - t.IDPeekU8: {one, false},
|
|
|
|
t.IDPeekU16BE - t.IDPeekU8: {two, false},
|
|
t.IDPeekU16LE - t.IDPeekU8: {two, false},
|
|
|
|
t.IDPeekU8AsU32 - t.IDPeekU8: {one, false},
|
|
t.IDPeekU16BEAsU32 - t.IDPeekU8: {two, false},
|
|
t.IDPeekU16LEAsU32 - t.IDPeekU8: {two, false},
|
|
t.IDPeekU24BEAsU32 - t.IDPeekU8: {three, false},
|
|
t.IDPeekU24LEAsU32 - t.IDPeekU8: {three, false},
|
|
t.IDPeekU32BE - t.IDPeekU8: {four, false},
|
|
t.IDPeekU32LE - t.IDPeekU8: {four, false},
|
|
|
|
t.IDPeekU8AsU64 - t.IDPeekU8: {one, false},
|
|
t.IDPeekU16BEAsU64 - t.IDPeekU8: {two, false},
|
|
t.IDPeekU16LEAsU64 - t.IDPeekU8: {two, false},
|
|
t.IDPeekU24BEAsU64 - t.IDPeekU8: {three, false},
|
|
t.IDPeekU24LEAsU64 - t.IDPeekU8: {three, false},
|
|
t.IDPeekU32BEAsU64 - t.IDPeekU8: {four, false},
|
|
t.IDPeekU32LEAsU64 - t.IDPeekU8: {four, false},
|
|
t.IDPeekU40BEAsU64 - t.IDPeekU8: {five, false},
|
|
t.IDPeekU40LEAsU64 - t.IDPeekU8: {five, false},
|
|
t.IDPeekU48BEAsU64 - t.IDPeekU8: {six, false},
|
|
t.IDPeekU48LEAsU64 - t.IDPeekU8: {six, false},
|
|
t.IDPeekU56BEAsU64 - t.IDPeekU8: {seven, false},
|
|
t.IDPeekU56LEAsU64 - t.IDPeekU8: {seven, false},
|
|
t.IDPeekU64BE - t.IDPeekU8: {eight, false},
|
|
t.IDPeekU64LE - t.IDPeekU8: {eight, false},
|
|
|
|
t.IDPokeU8 - t.IDPeekU8: {one, false},
|
|
t.IDPokeU16BE - t.IDPeekU8: {two, false},
|
|
t.IDPokeU16LE - t.IDPeekU8: {two, false},
|
|
t.IDPokeU24BE - t.IDPeekU8: {three, false},
|
|
t.IDPokeU24LE - t.IDPeekU8: {three, false},
|
|
t.IDPokeU32BE - t.IDPeekU8: {four, false},
|
|
t.IDPokeU32LE - t.IDPeekU8: {four, false},
|
|
t.IDPokeU40BE - t.IDPeekU8: {five, false},
|
|
t.IDPokeU40LE - t.IDPeekU8: {five, false},
|
|
t.IDPokeU48BE - t.IDPeekU8: {six, false},
|
|
t.IDPokeU48LE - t.IDPeekU8: {six, false},
|
|
t.IDPokeU56BE - t.IDPeekU8: {seven, false},
|
|
t.IDPokeU56LE - t.IDPeekU8: {seven, false},
|
|
t.IDPokeU64BE - t.IDPeekU8: {eight, false},
|
|
t.IDPokeU64LE - t.IDPeekU8: {eight, false},
|
|
|
|
t.IDWriteU8Fast - t.IDPeekU8: {one, true},
|
|
t.IDWriteU16BEFast - t.IDPeekU8: {two, true},
|
|
t.IDWriteU16LEFast - t.IDPeekU8: {two, true},
|
|
t.IDWriteU24BEFast - t.IDPeekU8: {three, true},
|
|
t.IDWriteU24LEFast - t.IDPeekU8: {three, true},
|
|
t.IDWriteU32BEFast - t.IDPeekU8: {four, true},
|
|
t.IDWriteU32LEFast - t.IDPeekU8: {four, true},
|
|
t.IDWriteU40BEFast - t.IDPeekU8: {five, true},
|
|
t.IDWriteU40LEFast - t.IDPeekU8: {five, true},
|
|
t.IDWriteU48BEFast - t.IDPeekU8: {six, true},
|
|
t.IDWriteU48LEFast - t.IDPeekU8: {six, true},
|
|
t.IDWriteU56BEFast - t.IDPeekU8: {seven, true},
|
|
t.IDWriteU56LEFast - t.IDPeekU8: {seven, true},
|
|
t.IDWriteU64BEFast - t.IDPeekU8: {eight, true},
|
|
t.IDWriteU64LEFast - t.IDPeekU8: {eight, true},
|
|
|
|
t.IDWriteSimpleTokenFast - t.IDPeekU8: {one, true},
|
|
t.IDWriteExtendedTokenFast - t.IDPeekU8: {one, true},
|
|
}
|
|
|
|
func makeConstValueExpr(tm *t.Map, cv *big.Int) (*a.Expr, error) {
|
|
id, err := tm.Insert(cv.String())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
o := a.NewExpr(0, 0, id, nil, nil, nil, nil)
|
|
o.SetConstValue(cv)
|
|
o.SetMBounds(bounds{cv, cv})
|
|
o.SetMType(typeExprIdeal)
|
|
return o, nil
|
|
}
|
|
|
|
// makeCanUndoByte returns "x.can_undo_byte()".
|
|
func makeCanUndoByte(x *a.Expr) *a.Expr {
|
|
ret := a.NewExpr(0, t.IDDot, t.IDCanUndoByte, x.AsNode(), nil, nil, nil)
|
|
ret.SetMBounds(bounds{funcBounds, funcBounds})
|
|
ret.SetMType(a.NewTypeExpr(t.IDFunc, 0, t.IDCanUndoByte, x.MType().AsNode(), nil, nil))
|
|
ret = a.NewExpr(0, t.IDOpenParen, 0, ret.AsNode(), nil, nil, nil)
|
|
// TODO: call SetMBounds?
|
|
ret.SetMType(typeExprBool)
|
|
return ret
|
|
}
|
|
|
|
// makeSliceLength returns "x.length()".
|
|
func makeSliceLength(x *a.Expr) *a.Expr {
|
|
ret := a.NewExpr(0, t.IDDot, t.IDLength, x.AsNode(), nil, nil, nil)
|
|
ret.SetMBounds(bounds{funcBounds, funcBounds})
|
|
ret.SetMType(a.NewTypeExpr(t.IDFunc, 0, t.IDLength, x.MType().AsNode(), nil, nil))
|
|
ret = a.NewExpr(0, t.IDOpenParen, 0, ret.AsNode(), nil, nil, nil)
|
|
// TODO: call SetMBounds?
|
|
ret.SetMType(typeExprU64)
|
|
return ret
|
|
}
|
|
|
|
// makeSliceLengthEqEq returns "x.length() == n".
|
|
func (q *checker) makeSliceLengthEqEq(x *a.Expr, n t.ID) *a.Expr {
|
|
lhs := makeSliceLength(x)
|
|
|
|
nValue, err := strconv.Atoi(n.Str(q.tm))
|
|
if err != nil {
|
|
panic("check: internal error: makeSliceLengthEqEq called but not with a small integer")
|
|
}
|
|
cv := big.NewInt(int64(nValue))
|
|
|
|
rhs := a.NewExpr(0, 0, n, nil, nil, nil, nil)
|
|
rhs.SetConstValue(cv)
|
|
rhs.SetMBounds(bounds{cv, cv})
|
|
rhs.SetMType(typeExprIdeal)
|
|
|
|
ret := a.NewExpr(0, t.IDXBinaryEqEq, 0, lhs.AsNode(), nil, rhs.AsNode(), nil)
|
|
ret.SetMBounds(bounds{zero, one})
|
|
ret.SetMType(typeExprBool)
|
|
return ret
|
|
}
|
|
|
|
func (q *checker) bcheckExprUnaryOp(n *a.Expr, depth uint32) (bounds, error) {
|
|
rb, err := q.bcheckExpr(n.RHS().AsExpr(), depth)
|
|
if err != nil {
|
|
return bounds{}, err
|
|
}
|
|
|
|
switch n.Operator() {
|
|
case t.IDXUnaryPlus:
|
|
return rb, nil
|
|
case t.IDXUnaryMinus:
|
|
return bounds{neg(rb[1]), neg(rb[0])}, nil
|
|
case t.IDXUnaryNot:
|
|
return bounds{zero, one}, nil
|
|
}
|
|
|
|
return bounds{}, fmt.Errorf("check: unrecognized token (0x%X) for bcheckExprUnaryOp", n.Operator())
|
|
}
|
|
|
|
func (q *checker) bcheckExprXBinaryPlus(lhs *a.Expr, lb bounds, rhs *a.Expr, rb bounds) (bounds, error) {
|
|
return lb.Add(rb), nil
|
|
}
|
|
|
|
func (q *checker) bcheckExprXBinaryMinus(lhs *a.Expr, lb bounds, rhs *a.Expr, rb bounds) (bounds, error) {
|
|
nb := lb.Sub(rb)
|
|
for _, x := range q.facts {
|
|
xOp, xLHS, xRHS := parseBinaryOp(x)
|
|
if !lhs.Eq(xLHS) || !rhs.Eq(xRHS) {
|
|
continue
|
|
}
|
|
switch xOp {
|
|
case t.IDXBinaryLessThan:
|
|
nb[1] = min(nb[1], minusOne)
|
|
case t.IDXBinaryLessEq:
|
|
nb[1] = min(nb[1], zero)
|
|
case t.IDXBinaryGreaterEq:
|
|
nb[0] = max(nb[0], zero)
|
|
case t.IDXBinaryGreaterThan:
|
|
nb[0] = max(nb[0], one)
|
|
}
|
|
}
|
|
return nb, nil
|
|
}
|
|
|
|
func (q *checker) bcheckExprBinaryOp(op t.ID, lhs *a.Expr, rhs *a.Expr, depth uint32) (bounds, error) {
|
|
lb, err := q.bcheckExpr(lhs, depth)
|
|
if err != nil {
|
|
return bounds{}, err
|
|
}
|
|
return q.bcheckExprBinaryOp1(op, lhs, lb, rhs, depth)
|
|
}
|
|
|
|
func (q *checker) bcheckExprBinaryOp1(op t.ID, lhs *a.Expr, lb bounds, rhs *a.Expr, depth uint32) (bounds, error) {
|
|
rb, err := q.bcheckExpr(rhs, depth)
|
|
if err != nil {
|
|
return bounds{}, err
|
|
}
|
|
|
|
switch op {
|
|
case t.IDXBinaryPlus:
|
|
return q.bcheckExprXBinaryPlus(lhs, lb, rhs, rb)
|
|
|
|
case t.IDXBinaryMinus:
|
|
return q.bcheckExprXBinaryMinus(lhs, lb, rhs, rb)
|
|
|
|
case t.IDXBinaryStar:
|
|
return lb.Mul(rb), nil
|
|
|
|
case t.IDXBinarySlash, t.IDXBinaryPercent:
|
|
// Prohibit division by zero.
|
|
if lb[0].Sign() < 0 {
|
|
return bounds{}, fmt.Errorf("check: divide/modulus op argument %q is possibly negative", lhs.Str(q.tm))
|
|
}
|
|
if rb[0].Sign() <= 0 {
|
|
return bounds{}, fmt.Errorf("check: divide/modulus op argument %q is possibly non-positive", rhs.Str(q.tm))
|
|
}
|
|
if op == t.IDXBinarySlash {
|
|
nb, _ := lb.TryQuo(rb)
|
|
return nb, nil
|
|
}
|
|
return bounds{
|
|
zero,
|
|
big.NewInt(0).Sub(rb[1], one),
|
|
}, nil
|
|
|
|
case t.IDXBinaryShiftL, t.IDXBinaryTildeModShiftL, t.IDXBinaryShiftR:
|
|
shiftBounds := bounds{}
|
|
typeBounds := bounds{}
|
|
if lTyp := lhs.MType(); lTyp.IsNumType() {
|
|
id := int(lTyp.QID()[1])
|
|
if id < len(numShiftBounds) {
|
|
shiftBounds = numShiftBounds[id]
|
|
}
|
|
if id < len(numTypeBounds) {
|
|
typeBounds = numTypeBounds[id]
|
|
}
|
|
}
|
|
if shiftBounds[0] == nil {
|
|
return bounds{}, fmt.Errorf("check: shift op argument %q of type %q does not have unsigned integer type",
|
|
lhs.Str(q.tm), lhs.MType().Str(q.tm))
|
|
} else if !shiftBounds.ContainsIntRange(rb) {
|
|
return bounds{}, fmt.Errorf("check: shift op argument %q is outside the range %s", rhs.Str(q.tm), shiftBounds)
|
|
}
|
|
|
|
switch op {
|
|
case t.IDXBinaryShiftL:
|
|
nb, _ := lb.TryLsh(rb)
|
|
return nb, nil
|
|
case t.IDXBinaryTildeModShiftL:
|
|
nb, _ := lb.TryLsh(rb)
|
|
nb[1] = min(nb[1], typeBounds[1])
|
|
return nb, nil
|
|
case t.IDXBinaryShiftR:
|
|
nb, _ := lb.TryRsh(rb)
|
|
return nb, nil
|
|
}
|
|
|
|
case t.IDXBinaryAmp, t.IDXBinaryPipe, t.IDXBinaryHat:
|
|
// TODO: should type-checking ensure that bitwise ops only apply to
|
|
// *unsigned* integer types?
|
|
if lb[0].Sign() < 0 {
|
|
return bounds{}, fmt.Errorf("check: bitwise op argument %q is possibly negative", lhs.Str(q.tm))
|
|
}
|
|
if rb[0].Sign() < 0 {
|
|
return bounds{}, fmt.Errorf("check: bitwise op argument %q is possibly negative", rhs.Str(q.tm))
|
|
}
|
|
switch op {
|
|
case t.IDXBinaryAmp:
|
|
return lb.And(rb), nil
|
|
case t.IDXBinaryPipe:
|
|
return lb.Or(rb), nil
|
|
case t.IDXBinaryHat:
|
|
z := max(lb[1], rb[1])
|
|
// Return [0, z rounded up to the next power-of-2-minus-1]. This is
|
|
// conservative, but works fine in practice.
|
|
return bounds{
|
|
zero,
|
|
bitMask(z.BitLen()),
|
|
}, nil
|
|
}
|
|
|
|
case t.IDXBinaryTildeModPlus, t.IDXBinaryTildeModMinus, t.IDXBinaryTildeModStar:
|
|
typ := lhs.MType()
|
|
if typ.IsIdeal() {
|
|
typ = rhs.MType()
|
|
}
|
|
if qid := typ.QID(); qid[0] == t.IDBase {
|
|
return numTypeBounds[qid[1]], nil
|
|
}
|
|
|
|
case t.IDXBinaryTildeSatPlus, t.IDXBinaryTildeSatMinus:
|
|
typ := lhs.MType()
|
|
if typ.IsIdeal() {
|
|
typ = rhs.MType()
|
|
}
|
|
if qid := typ.QID(); qid[0] == t.IDBase {
|
|
b := numTypeBounds[qid[1]]
|
|
|
|
nFunc := (*checker).bcheckExprXBinaryPlus
|
|
if op != t.IDXBinaryTildeSatPlus {
|
|
nFunc = (*checker).bcheckExprXBinaryMinus
|
|
}
|
|
nb, err := nFunc(q, lhs, lb, rhs, rb)
|
|
if err != nil {
|
|
return bounds{}, err
|
|
}
|
|
|
|
if op == t.IDXBinaryTildeSatPlus {
|
|
nb[0] = min(nb[0], b[1])
|
|
nb[1] = min(nb[1], b[1])
|
|
} else {
|
|
nb[0] = max(nb[0], b[0])
|
|
nb[1] = max(nb[1], b[0])
|
|
}
|
|
return nb, nil
|
|
}
|
|
|
|
case t.IDXBinaryNotEq, t.IDXBinaryLessThan, t.IDXBinaryLessEq, t.IDXBinaryEqEq,
|
|
t.IDXBinaryGreaterEq, t.IDXBinaryGreaterThan, t.IDXBinaryAnd, t.IDXBinaryOr:
|
|
return bounds{zero, one}, nil
|
|
|
|
case t.IDXBinaryAs:
|
|
// Unreachable, as this is checked by the caller.
|
|
}
|
|
return bounds{}, fmt.Errorf("check: unrecognized token (0x%X) for bcheckExprBinaryOp", op)
|
|
}
|
|
|
|
func (q *checker) bcheckExprAssociativeOp(n *a.Expr, depth uint32) (bounds, error) {
|
|
op := n.Operator().AmbiguousForm().BinaryForm()
|
|
if op == 0 {
|
|
return bounds{}, fmt.Errorf(
|
|
"check: unrecognized token (0x%X) for bcheckExprAssociativeOp", n.Operator())
|
|
}
|
|
args := n.Args()
|
|
if len(args) < 1 {
|
|
return bounds{}, fmt.Errorf("check: associative op has no arguments")
|
|
}
|
|
lb, err := q.bcheckExpr(args[0].AsExpr(), depth)
|
|
if err != nil {
|
|
return bounds{}, err
|
|
}
|
|
for i, o := range args {
|
|
if i == 0 {
|
|
continue
|
|
}
|
|
lhs := a.NewExpr(n.AsNode().AsRaw().Flags(),
|
|
n.Operator(), n.Ident(), n.LHS(), n.MHS(), n.RHS(), args[:i])
|
|
lb, err = q.bcheckExprBinaryOp1(op, lhs, lb, o.AsExpr(), depth)
|
|
if err != nil {
|
|
return bounds{}, err
|
|
}
|
|
}
|
|
return lb, nil
|
|
}
|
|
|
|
func (q *checker) bcheckTypeExpr(typ *a.TypeExpr) (bounds, error) {
|
|
if b := typ.AsNode().MBounds(); b[0] != nil {
|
|
return b, nil
|
|
}
|
|
b, err := q.bcheckTypeExpr1(typ)
|
|
if err != nil {
|
|
return bounds{}, err
|
|
}
|
|
typ.AsNode().SetMBounds(b)
|
|
return b, nil
|
|
}
|
|
|
|
func (q *checker) bcheckTypeExpr1(typ *a.TypeExpr) (bounds, error) {
|
|
if typ.IsIdeal() {
|
|
return bounds{minIdeal, maxIdeal}, nil
|
|
}
|
|
|
|
if innTyp := typ.Inner(); innTyp != nil {
|
|
if _, err := q.bcheckTypeExpr(innTyp); err != nil {
|
|
return bounds{}, err
|
|
}
|
|
}
|
|
|
|
switch typ.Decorator() {
|
|
case 0:
|
|
// No-op.
|
|
case t.IDArray, t.IDRoarray:
|
|
if _, err := q.bcheckExpr(typ.ArrayLength(), 0); err != nil {
|
|
return bounds{}, err
|
|
}
|
|
return bounds{zero, zero}, nil
|
|
case t.IDFunc:
|
|
if _, err := q.bcheckTypeExpr(typ.Receiver()); err != nil {
|
|
return bounds{}, err
|
|
}
|
|
return bounds{one, funcBounds}, nil
|
|
case t.IDNptr:
|
|
return bounds{zero, maxPointerBounds}, nil
|
|
case t.IDPtr:
|
|
return bounds{one, maxPointerBounds}, nil
|
|
case t.IDRoslice, t.IDRotable, t.IDSlice, t.IDTable:
|
|
return bounds{zero, zero}, nil
|
|
default:
|
|
return bounds{}, fmt.Errorf("check: internal error: unrecognized decorator")
|
|
}
|
|
|
|
b := bounds{zero, zero}
|
|
|
|
if qid := typ.QID(); qid[0] == t.IDBase {
|
|
if qid[1] == t.IDDagger1 || qid[1] == t.IDDagger2 {
|
|
return bounds{zero, zero}, nil
|
|
} else if qid[1] < t.ID(len(numTypeBounds)) {
|
|
if x := numTypeBounds[qid[1]]; x[0] != nil {
|
|
b = x
|
|
}
|
|
}
|
|
}
|
|
|
|
if typ.IsRefined() {
|
|
if x := typ.Min(); x != nil {
|
|
if _, err := q.bcheckExpr(x, 0); err != nil {
|
|
return bounds{}, err
|
|
}
|
|
if cv := x.ConstValue(); cv == nil {
|
|
return bounds{}, fmt.Errorf("check: internal error: refinement has no const-value")
|
|
} else if cv.Cmp(b[0]) < 0 {
|
|
return bounds{}, fmt.Errorf("check: type refinement %v for %q is out of bounds", cv, typ.Str(q.tm))
|
|
} else {
|
|
b[0] = cv
|
|
}
|
|
}
|
|
|
|
if x := typ.Max(); x != nil {
|
|
if _, err := q.bcheckExpr(x, 0); err != nil {
|
|
return bounds{}, err
|
|
}
|
|
if cv := x.ConstValue(); cv == nil {
|
|
return bounds{}, fmt.Errorf("check: internal error: refinement has no const-value")
|
|
} else if cv.Cmp(b[1]) > 0 {
|
|
return bounds{}, fmt.Errorf("check: type refinement %v for %q is out of bounds", cv, typ.Str(q.tm))
|
|
} else {
|
|
b[1] = cv
|
|
}
|
|
}
|
|
}
|
|
|
|
return b, nil
|
|
}
|