From bb4477d91f378981202437d5f8dfbc2302e85247 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Sun, 1 Jul 2018 10:26:17 +1000 Subject: [PATCH] Add peek_uxx methods --- cmd/wuffs-c/internal/cgen/builtin.go | 34 +++++++++ doc/changelog.md | 1 + lang/builtin/builtin.go | 18 +++++ lang/check/bounds.go | 108 +++++++++++++++++++-------- lang/check/optimize.go | 38 ++++++---- lang/token/list.go | 32 ++++++++ 6 files changed, 187 insertions(+), 44 deletions(-) diff --git a/cmd/wuffs-c/internal/cgen/builtin.go b/cmd/wuffs-c/internal/cgen/builtin.go index 7acd4a47..3a4246d6 100644 --- a/cmd/wuffs-c/internal/cgen/builtin.go +++ b/cmd/wuffs-c/internal/cgen/builtin.go @@ -131,6 +131,19 @@ func (g *gen) writeBuiltinIOReader(b *buffer, recv *a.Expr, method t.ID, args [] ".len = (size_t)(ioptr_src - %ssrc.private_impl.bounds[0]), })", aPrefix, aPrefix) return nil + + case t.IDPeekU8: + b.writes("(*ioptr_src)") + return nil + } + + if method >= t.IDPeekU8 { + if m := method - t.IDPeekU8; m < t.ID(len(peekMethods)) { + if p := peekMethods[m]; p.n != 0 { + b.printf("wuffs_base__load_u%d%ce(ioptr_src)", p.n, p.endianness) + return nil + } + } } return g.writeBuiltinIO(b, recv, method, args, rp, depth) @@ -473,3 +486,24 @@ func (g *gen) writeBuiltinCallSuspendibles(b *buffer, n *a.Expr, depth uint32) e } return errNoSuchBuiltin } + +var peekMethods = [...]struct { + n uint8 + endianness uint8 +}{ + // t.IDPeekU8 is a special case, neither big nor little endian. + t.IDPeekU16BE - t.IDPeekU8: {16, 'b'}, + t.IDPeekU16LE - t.IDPeekU8: {16, 'l'}, + t.IDPeekU24BE - t.IDPeekU8: {24, 'b'}, + t.IDPeekU24LE - t.IDPeekU8: {24, 'l'}, + t.IDPeekU32BE - t.IDPeekU8: {32, 'b'}, + t.IDPeekU32LE - t.IDPeekU8: {32, 'l'}, + t.IDPeekU40BE - t.IDPeekU8: {40, 'b'}, + t.IDPeekU40LE - t.IDPeekU8: {40, 'l'}, + t.IDPeekU48BE - t.IDPeekU8: {48, 'b'}, + t.IDPeekU48LE - t.IDPeekU8: {48, 'l'}, + t.IDPeekU56BE - t.IDPeekU8: {56, 'b'}, + t.IDPeekU56LE - t.IDPeekU8: {56, 'l'}, + t.IDPeekU64BE - t.IDPeekU8: {64, 'b'}, + t.IDPeekU64LE - t.IDPeekU8: {64, 'l'}, +} diff --git a/doc/changelog.md b/doc/changelog.md index f7084481..1c32f57d 100644 --- a/doc/changelog.md +++ b/doc/changelog.md @@ -21,6 +21,7 @@ - Redesigned iterate blocks. - Added a `base.image_config` type. - Added a `reset` method. +- Added `peek_uxx` methods. - Tweaked how marks and limits work. - Supported animated (not just single frame) GIFs. - Marked the `std/gif` LZW decoder as private. diff --git a/lang/builtin/builtin.go b/lang/builtin/builtin.go index e104137b..ee38e698 100644 --- a/lang/builtin/builtin.go +++ b/lang/builtin/builtin.go @@ -157,6 +157,24 @@ var Funcs = []string{ "io_reader.read_u64be?()(ret u64)", "io_reader.read_u64le?()(ret u64)", + // TODO: these methods should have an explicit precondition on "available() + // >= N". For now, that's implicitly checked (i.e. hard coded). + "io_reader.peek_u8()(ret u8)", + "io_reader.peek_u16be()(ret u16)", + "io_reader.peek_u16le()(ret u16)", + "io_reader.peek_u24be()(ret u32[..0xFFFFFF])", + "io_reader.peek_u24le()(ret u32[..0xFFFFFF])", + "io_reader.peek_u32be()(ret u32)", + "io_reader.peek_u32le()(ret u32)", + "io_reader.peek_u40be()(ret u64[..0xFFFFFFFFFF])", + "io_reader.peek_u40le()(ret u64[..0xFFFFFFFFFF])", + "io_reader.peek_u48be()(ret u64[..0xFFFFFFFFFFFF])", + "io_reader.peek_u48le()(ret u64[..0xFFFFFFFFFFFF])", + "io_reader.peek_u56be()(ret u64[..0xFFFFFFFFFFFFFF])", + "io_reader.peek_u56le()(ret u64[..0xFFFFFFFFFFFFFF])", + "io_reader.peek_u64be()(ret u64)", + "io_reader.peek_u64le()(ret u64)", + "io_reader.available()(ret u64)", "io_reader.set!(s slice u8, closed bool)()", "io_reader.set_limit!(l u64)()", diff --git a/lang/check/bounds.go b/lang/check/bounds.go index 07c7a0db..77417c69 100644 --- a/lang/check/bounds.go +++ b/lang/check/bounds.go @@ -800,36 +800,10 @@ func (q *checker) bcheckExprOther(n *a.Expr, depth uint32) (*big.Int, *big.Int, if err := q.bcheckExprCall(n, depth); err != nil { return nil, nil, err } - - // Special case for a numeric type's low_bits, high_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. - if recv := lhs.MType().Receiver(); recv != nil && recv.IsNumType() { - switch methodName := lhs.Ident(); methodName { - case t.IDLowBits, t.IDHighBits: - _, aMax, err := q.bcheckExpr(n.Args()[0].Arg().Value(), depth) - if err != nil { - return nil, nil, err - } - return zero, bitMask(int(aMax.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. - lMin, lMax, err := q.bcheckExpr(lhs.LHS().Expr(), depth) - if err != nil { - return nil, nil, err - } - aMin, aMax, err := q.bcheckExpr(n.Args()[0].Arg().Value(), depth) - if err != nil { - return nil, nil, err - } - if methodName == t.IDMin { - return min(lMin, aMin), min(lMax, aMax), nil - } else { - return max(lMin, aMin), max(lMax, aMax), nil - } - } + if nMin, nMax, err := q.bcheckExprCallSpecialCases(n, depth); err != nil { + return nil, nil, err + } else if nMin != nil || nMax != nil { + return nMin, nMax, nil } case t.IDOpenBracket: @@ -956,6 +930,80 @@ func (q *checker) bcheckExprCall(n *a.Expr, depth uint32) error { return nil } +func (q *checker) bcheckExprCallSpecialCases(n *a.Expr, depth uint32) (*big.Int, *big.Int, error) { + lhs := n.LHS().Expr() + recv := lhs.LHS().Expr() + method := lhs.Ident() + + if recvTyp := recv.MType(); recvTyp == nil { + return nil, nil, nil + + } 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: + _, aMax, err := q.bcheckExpr(n.Args()[0].Arg().Value(), depth) + if err != nil { + return nil, nil, err + } + return zero, bitMask(int(aMax.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. + lMin, lMax, err := q.bcheckExpr(lhs.LHS().Expr(), depth) + if err != nil { + return nil, nil, err + } + aMin, aMax, err := q.bcheckExpr(n.Args()[0].Arg().Value(), depth) + if err != nil { + return nil, nil, err + } + if method == t.IDMin { + return min(lMin, aMin), min(lMax, aMax), nil + } else { + return max(lMin, aMin), max(lMax, aMax), nil + } + } + + } else if recvTyp.IsIOType() { + if method >= t.IDPeekU8 { + if m := method - t.IDPeekU8; m < t.ID(len(ioMethodAdvances)) { + if advance := ioMethodAdvances[m]; advance != nil { + if ok, err := q.optimizeIOMethodAdvance(recv, advance, false); err != nil { + return nil, nil, err + } else if !ok { + return nil, nil, fmt.Errorf("check: could not prove %s precondition: %s.available() >= %v", + method.Str(q.tm), recv.Str(q.tm), advance) + } + } + } + } + } + + return nil, nil, nil +} + +var ioMethodAdvances = [...]*big.Int{ + t.IDPeekU8 - t.IDPeekU8: one, + t.IDPeekU16BE - t.IDPeekU8: two, + t.IDPeekU16LE - t.IDPeekU8: two, + t.IDPeekU24BE - t.IDPeekU8: three, + t.IDPeekU24LE - t.IDPeekU8: three, + t.IDPeekU32BE - t.IDPeekU8: four, + t.IDPeekU32LE - t.IDPeekU8: four, + t.IDPeekU40BE - t.IDPeekU8: five, + t.IDPeekU40LE - t.IDPeekU8: five, + t.IDPeekU48BE - t.IDPeekU8: six, + t.IDPeekU48LE - t.IDPeekU8: six, + t.IDPeekU56BE - t.IDPeekU8: seven, + t.IDPeekU56LE - t.IDPeekU8: seven, + t.IDPeekU64BE - t.IDPeekU8: eight, + t.IDPeekU64LE - t.IDPeekU8: eight, +} + // makeSliceLength returns "x.length()". func makeSliceLength(slice *a.Expr) *a.Expr { x := a.NewExpr(0, t.IDDot, 0, t.IDLength, slice.Node(), nil, nil, nil) diff --git a/lang/check/optimize.go b/lang/check/optimize.go index b5344725..6fa0868e 100644 --- a/lang/check/optimize.go +++ b/lang/check/optimize.go @@ -213,14 +213,21 @@ func (q *checker) optimizeSuspendible(n *a.Expr, depth uint32) error { } if advance := ioMethodAdvance(nMethod); advance != nil { - return q.optimizeIOMethodAdvance(n, nReceiver, advance) + if ok, err := q.optimizeIOMethodAdvance(nReceiver, advance, true); err != nil { + return err + } else if ok { + n.SetProvenNotToSuspend() + } } return nil } -func (q *checker) optimizeIOMethodAdvance(n *a.Expr, receiver *a.Expr, advance *big.Int) error { - return q.facts.update(func(x *a.Expr) (*a.Expr, error) { +func (q *checker) optimizeIOMethodAdvance(receiver *a.Expr, advance *big.Int, update bool) (retOK bool, retErr error) { + retErr = q.facts.update(func(x *a.Expr) (*a.Expr, error) { + // TODO: update (discard?) any facts that merely mention + // receiver.available(), even if they aren't an exact match. + op := x.Operator() if op != t.IDXBinaryGreaterEq && op != t.IDXBinaryGreaterThan { return x, nil @@ -247,33 +254,36 @@ func (q *checker) optimizeIOMethodAdvance(n *a.Expr, receiver *a.Expr, advance * // Check if the bytes available is >= the bytes needed. If so, update // rcv to be the bytes remaining. If not, discard the fact x. - // - // TODO: mark the call as proven not to suspend. if op == t.IDXBinaryGreaterThan { op = t.IDXBinaryGreaterEq rcv = big.NewInt(0).Add(rcv, one) } if rcv.Cmp(advance) < 0 { + if !update { + return x, nil + } return nil, nil } - rcv = big.NewInt(0).Sub(rcv, advance) - // Create a new a.Expr to hold the adjusted RHS constant value rcv. - id, err := q.tm.Insert(rcv.String()) + retOK = true + + if !update { + return x, nil + } + + // Create a new a.Expr to hold the adjusted RHS constant value, newRCV. + newRCV := big.NewInt(0).Sub(rcv, advance) + id, err := q.tm.Insert(newRCV.String()) if err != nil { return nil, err } o := a.NewExpr(0, 0, 0, id, nil, nil, nil, nil) - o.SetConstValue(rcv) + o.SetConstValue(newRCV) o.SetMType(typeExprIdeal) - if !n.CallSuspendible() { - return nil, fmt.Errorf("check: internal error: inconsistent suspendible-ness for %q", n.Str(q.tm)) - } - n.SetProvenNotToSuspend() - return a.NewExpr(x.Node().Raw().Flags(), t.IDXBinaryGreaterEq, 0, 0, x.LHS(), nil, o.Node(), nil), nil }) + return retOK, retErr } func ioMethodAdvance(x t.ID) *big.Int { diff --git a/lang/token/list.go b/lang/token/list.go index 798c3eca..2b82fb27 100644 --- a/lang/token/list.go +++ b/lang/token/list.go @@ -461,6 +461,22 @@ const ( IDReadU64BE = ID(0x14E) IDReadU64LE = ID(0x14F) + IDPeekU8 = ID(0x151) + IDPeekU16BE = ID(0x152) + IDPeekU16LE = ID(0x153) + IDPeekU24BE = ID(0x154) + IDPeekU24LE = ID(0x155) + IDPeekU32BE = ID(0x156) + IDPeekU32LE = ID(0x157) + IDPeekU40BE = ID(0x158) + IDPeekU40LE = ID(0x159) + IDPeekU48BE = ID(0x15A) + IDPeekU48LE = ID(0x15B) + IDPeekU56BE = ID(0x15C) + IDPeekU56LE = ID(0x15D) + IDPeekU64BE = ID(0x15E) + IDPeekU64LE = ID(0x15F) + // TODO: IDUnwriteU8? IDWriteU8 = ID(0x161) IDWriteU16BE = ID(0x162) @@ -703,6 +719,22 @@ var builtInsByID = [nBuiltInIDs]string{ IDReadU64BE: "read_u64be", IDReadU64LE: "read_u64le", + IDPeekU8: "peek_u8", + IDPeekU16BE: "peek_u16be", + IDPeekU16LE: "peek_u16le", + IDPeekU24BE: "peek_u24be", + IDPeekU24LE: "peek_u24le", + IDPeekU32BE: "peek_u32be", + IDPeekU32LE: "peek_u32le", + IDPeekU40BE: "peek_u40be", + IDPeekU40LE: "peek_u40le", + IDPeekU48BE: "peek_u48be", + IDPeekU48LE: "peek_u48le", + IDPeekU56BE: "peek_u56be", + IDPeekU56LE: "peek_u56le", + IDPeekU64BE: "peek_u64be", + IDPeekU64LE: "peek_u64le", + IDWriteU8: "write_u8", IDWriteU16BE: "write_u16be", IDWriteU16LE: "write_u16le",