Add peek_uxx methods

This commit is contained in:
Nigel Tao committed 2018-07-01 10:26:17 +10:00
1 parent 3896c1940f
commit bb4477d91f
6 files changed
+187 -44

No files matched your search

+34
View File
@@ -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'},
}
+1
View File
@@ -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.
+18
View File
@@ -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)()",
+78 -30
View File
@@ -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)
+24 -14
View File
@@ -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 {
+32
View File
@@ -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",