From f9cea5c17cb7f19d5ec163191b41ebe146e64797 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Thu, 19 Oct 2017 20:45:43 +1100 Subject: [PATCH] Fix the adler.update implementation. --- cmd/puffs-c/internal/cgen/expr.go | 4 ++ gen/c/std/flate.c | 2 +- lang/check/bounds.go | 45 ++++++------- lang/check/type.go | 6 +- script/adler32sum.go | 44 +++++++++++++ std/flate/decode_zlib.puffs | 5 +- test/c/mimiclib/flate.c | 16 ++--- test/c/std/flate.c | 104 ++++++++++++++++++++++++++++-- 8 files changed, 186 insertions(+), 40 deletions(-) create mode 100644 script/adler32sum.go diff --git a/cmd/puffs-c/internal/cgen/expr.go b/cmd/puffs-c/internal/cgen/expr.go index 75756542..6ea777d1 100644 --- a/cmd/puffs-c/internal/cgen/expr.go +++ b/cmd/puffs-c/internal/cgen/expr.go @@ -273,6 +273,10 @@ func (g *gen) writeExprOther(b *buffer, n *a.Expr, rp replacementPolicy, pp pare if err := g.writeExpr(b, n.LHS().Expr(), rp, parenthesesMandatory, depth); err != nil { return err } + if lTyp := n.LHS().Expr().MType(); lTyp.Decorator().Key() == t.KeyColon { + // TODO: don't assume that the slice is a slice of u8. + b.writes(".ptr") + } b.writeb('[') if err := g.writeExpr(b, n.RHS().Expr(), rp, parenthesesOptional, depth); err != nil { return err diff --git a/gen/c/std/flate.c b/gen/c/std/flate.c index afc2413e..e9c43f00 100644 --- a/gen/c/std/flate.c +++ b/gen/c/std/flate.c @@ -2440,7 +2440,7 @@ uint32_t puffs_flate_adler_update(puffs_flate_adler* self, } v_i = 0; while (v_i < ((uint64_t)(a_x.len))) { - v_s1 += 42; + v_s1 += ((uint32_t)(a_x.ptr[v_i])); v_s2 += v_s1; v_i += 1; } diff --git a/lang/check/bounds.go b/lang/check/bounds.go index 541dd94b..b3024baf 100644 --- a/lang/check/bounds.go +++ b/lang/check/bounds.go @@ -796,18 +796,23 @@ func (q *checker) bcheckExprOther(n *a.Expr, depth uint32) (*big.Int, *big.Int, return nil, nil, err } rhs := n.RHS().Expr() - rMin, rMax, err := q.bcheckExpr(rhs, depth) + _, _, err = q.bcheckExpr(rhs, depth) if err != nil { return nil, nil, err } - cv := lhs.MType().ArrayLength().ConstValue() - if cv == nil { - return nil, nil, fmt.Errorf("check: cannot determine constant array length for %q", - lhs.MType().String(q.tm)) + + lengthExpr := (*a.Expr)(nil) + if lTyp := lhs.MType(); lTyp.Decorator().Key() == t.KeyOpenBracket { + lengthExpr = lTyp.ArrayLength() + } else { + lengthExpr = makeSliceLengthExpr(lhs) } - if rMin.Cmp(zero) < 0 || rMax.Cmp(cv) >= 0 { - return nil, nil, fmt.Errorf("check: array index %q (of range %v..%v) out of range", - rhs.String(q.tm), rMin, rMax) + + if err := proveReasonRequirement(q, t.IDXBinaryLessEq, zeroExpr, rhs); err != nil { + return nil, nil, err + } + if err := proveReasonRequirement(q, t.IDXBinaryLessThan, rhs, lengthExpr); err != nil { + return nil, nil, err } case t.KeyColon: @@ -820,21 +825,9 @@ func (q *checker) bcheckExprOther(n *a.Expr, depth uint32) (*big.Int, *big.Int, lengthExpr := (*a.Expr)(nil) if lTyp := lhs.MType(); lTyp.Decorator().Key() == t.KeyOpenBracket { - // Slice of an array. - cv := lTyp.ArrayLength().ConstValue() - id, err := q.tm.Insert(cv.String()) - if err != nil { - return nil, nil, err - } - lengthExpr = a.NewExpr(a.FlagsTypeChecked, 0, id, nil, nil, nil, nil) - lengthExpr.SetConstValue(cv) - lengthExpr.SetMType(typeExprIdeal) + lengthExpr = lTyp.ArrayLength() } else { - // Slice of a slice. - lengthExpr = a.NewExpr(a.FlagsTypeChecked, t.IDDot, t.IDLength, lhs.Node(), nil, nil, nil) - lengthExpr.SetMType(typeExprPlaceholder) // HACK. - lengthExpr = a.NewExpr(a.FlagsTypeChecked, t.IDOpenParen, 0, lengthExpr.Node(), nil, nil, nil) - lengthExpr.SetMType(typeExprU64) + lengthExpr = makeSliceLengthExpr(lhs) } if mhs == nil { @@ -886,6 +879,14 @@ func (q *checker) bcheckExprOther(n *a.Expr, depth uint32) (*big.Int, *big.Int, return q.bcheckTypeExpr(n.MType()) } +func makeSliceLengthExpr(slice *a.Expr) *a.Expr { + x := a.NewExpr(a.FlagsTypeChecked, t.IDDot, t.IDLength, slice.Node(), nil, nil, nil) + x.SetMType(typeExprPlaceholder) // HACK. + x = a.NewExpr(a.FlagsTypeChecked, t.IDOpenParen, 0, x.Node(), nil, nil, nil) + x.SetMType(typeExprU64) + return x +} + func (q *checker) bcheckExprUnaryOp(n *a.Expr, depth uint32) (*big.Int, *big.Int, error) { rMin, rMax, err := q.bcheckExpr(n.RHS().Expr(), depth) if err != nil { diff --git a/lang/check/type.go b/lang/check/type.go index 7463a804..909dac11 100644 --- a/lang/check/type.go +++ b/lang/check/type.go @@ -509,13 +509,13 @@ func (q *checker) tcheckExprOther(n *a.Expr, depth uint32) error { return err } lTyp := lhs.MType() - if lTyp.Decorator().Key() != t.KeyOpenBracket { - return fmt.Errorf("check: %s is an array-index expression but %s has type %s, not an array type", + if key := lTyp.Decorator().Key(); key != t.KeyOpenBracket && key != t.KeyColon { + return fmt.Errorf("check: %s is an index expression but %s has type %s, not an array or slice type", n.String(q.tm), lhs.String(q.tm), lTyp.String(q.tm)) } rTyp := rhs.MType() if !rTyp.IsNumTypeOrIdeal() { - return fmt.Errorf("check: %s is an array-index expression but %s has type %s, not a numeric type", + return fmt.Errorf("check: %s is an index expression but %s has type %s, not a numeric type", n.String(q.tm), rhs.String(q.tm), rTyp.String(q.tm)) } n.SetMType(lTyp.Inner()) diff --git a/script/adler32sum.go b/script/adler32sum.go new file mode 100644 index 00000000..6400930b --- /dev/null +++ b/script/adler32sum.go @@ -0,0 +1,44 @@ +// Copyright 2017 The Puffs Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// +build ignore + +package main + +// adler32sum.go prints the Adler-32 checksum of stdin's bytes. +// +// Usage: go run adler32sum.go < foo.bar + +import ( + "fmt" + "hash/adler32" + "io" + "os" +) + +func main() { + if err := main1(); err != nil { + os.Stderr.WriteString(err.Error() + "\n") + os.Exit(1) + } +} + +func main1() error { + a := adler32.New() + if _, err := io.Copy(a, os.Stdin); err != nil { + return err + } + fmt.Printf("0x%08X\n", a.Sum32()) + return nil +} diff --git a/std/flate/decode_zlib.puffs b/std/flate/decode_zlib.puffs index 736151d3..776c9b5c 100644 --- a/std/flate/decode_zlib.puffs +++ b/std/flate/decode_zlib.puffs @@ -48,7 +48,8 @@ pri struct adler?( ) pri func adler.update(x[] u8)(checksum u32) { - // The magic 65521 and 5552 numbers are discussed in RFC 1950. + // The Adler-32 checksum's magic 65521 and 5552 numbers are discussed in + // RFC 1950. var s1 u32 = this.state.low_bits(n:16) var s2 u32 = this.state.high_bits(n:16) @@ -70,7 +71,7 @@ pri func adler.update(x[] u8)(checksum u32) { inv in.x.length() <= 5552, { assert i < 5552 via "a < b: a < c; c <= b"(c:in.x.length()) - s1 ~+= 42 // TODO. + s1 ~+= in.x[i] as u32 s2 ~+= s1 i += 1 } diff --git a/test/c/mimiclib/flate.c b/test/c/mimiclib/flate.c index e4198919..442041ce 100644 --- a/test/c/mimiclib/flate.c +++ b/test/c/mimiclib/flate.c @@ -16,10 +16,10 @@ uint32_t global_mimiclib_flate_unused_u32; -const char* mimic_adler32(puffs_base_buf1* dst, - puffs_base_buf1* src, - uint64_t wlimit, - uint64_t rlimit) { +const char* mimic_bench_adler32(puffs_base_buf1* dst, + puffs_base_buf1* src, + uint64_t wlimit, + uint64_t rlimit) { // TODO: don't ignore wlimit and rlimit. uint8_t* ptr = src->ptr + src->ri; size_t len = src->wi - src->ri; @@ -31,10 +31,10 @@ const char* mimic_adler32(puffs_base_buf1* dst, return NULL; } -const char* mimic_crc32(puffs_base_buf1* dst, - puffs_base_buf1* src, - uint64_t wlimit, - uint64_t rlimit) { +const char* mimic_bench_crc32(puffs_base_buf1* dst, + puffs_base_buf1* src, + uint64_t wlimit, + uint64_t rlimit) { // TODO: don't ignore wlimit and rlimit. uint8_t* ptr = src->ptr + src->ri; size_t len = src->wi - src->ri; diff --git a/test/c/std/flate.c b/test/c/std/flate.c index 3510105a..5564554f 100644 --- a/test/c/std/flate.c +++ b/test/c/std/flate.c @@ -111,6 +111,67 @@ golden_test zlib_pi_gt = { .src_filename = "../../testdata/pi.txt.zlib", // }; +// ---------------- Checksum Tests + +void test_puffs_adler32() { + proc_funcname = __func__; + + struct { + const char* filename; + // The want values are determined by script/adler32sum.go. + uint32_t want; + } test_cases[] = { + { + .filename = "../../testdata/hat.bmp", + .want = 0x3D26D034, + }, + { + .filename = "../../testdata/hat.gif", + .want = 0x2A5EB144, + }, + { + .filename = "../../testdata/hat.jpeg", + .want = 0x3A503B1A, + }, + { + .filename = "../../testdata/hat.lossless.webp", + .want = 0xD059D427, + }, + { + .filename = "../../testdata/hat.lossy.webp", + .want = 0xF1BB258D, + }, + { + .filename = "../../testdata/hat.png", + .want = 0xDFC6C9C6, + }, + { + .filename = "../../testdata/hat.tiff", + .want = 0xBDC011E9, + }, + }; + + int i; + for (i = 0; i < PUFFS_TESTLIB_ARRAY_SIZE(test_cases); i++) { + puffs_base_buf1 src = {.ptr = global_src_buffer, .len = BUFFER_SIZE}; + if (!read_file(&src, test_cases[i].filename)) { + return; + } + puffs_flate_adler checksum; + puffs_flate_adler_initialize(&checksum, PUFFS_VERSION, 0); + uint32_t got = + puffs_flate_adler_update(&checksum, ((puffs_base_slice_u8){ + .ptr = src.ptr + src.ri, + .len = src.wi - src.ri, + })); + if (got != test_cases[i].want) { + FAIL("i=%d, filename=\"%s\": got 0x%08" PRIX32 ", want 0x%08" PRIX32 "\n", + i, test_cases[i].filename, got, test_cases[i].want); + return; + } + } +} + // ---------------- Flate Tests const char* puffs_flate_decode(puffs_base_buf1* dst, @@ -624,6 +685,37 @@ void test_mimic_zlib_decode_pi() { #endif // PUFFS_MIMIC +// ---------------- Checksum Benches + +uint32_t global_puffs_flate_unused_u32; + +const char* puffs_bench_adler32(puffs_base_buf1* dst, + puffs_base_buf1* src, + uint64_t wlimit, + uint64_t rlimit) { + // TODO: don't ignore wlimit and rlimit. + puffs_flate_adler checksum; + puffs_flate_adler_initialize(&checksum, PUFFS_VERSION, 0); + global_puffs_flate_unused_u32 = + puffs_flate_adler_update(&checksum, ((puffs_base_slice_u8){ + .ptr = src->ptr + src->ri, + .len = src->wi - src->ri, + })); + src->ri = src->wi; + return NULL; +} + +void bench_puffs_adler32_10k() { + proc_funcname = __func__; + do_bench_buf1_buf1(puffs_bench_adler32, tc_src, &checksum_midsummer_gt, 0, 0, + 30000); +} + +void bench_puffs_adler32_100k() { + proc_funcname = __func__; + do_bench_buf1_buf1(puffs_bench_adler32, tc_src, &checksum_pi_gt, 0, 0, 3000); +} + // ---------------- Flate Benches void bench_puffs_flate_decode_1k() { @@ -648,23 +740,24 @@ void bench_puffs_flate_decode_100k() { void bench_mimic_adler32_10k() { proc_funcname = __func__; - do_bench_buf1_buf1(mimic_adler32, tc_src, &checksum_midsummer_gt, 0, 0, + do_bench_buf1_buf1(mimic_bench_adler32, tc_src, &checksum_midsummer_gt, 0, 0, 30000); } void bench_mimic_adler32_100k() { proc_funcname = __func__; - do_bench_buf1_buf1(mimic_adler32, tc_src, &checksum_pi_gt, 0, 0, 3000); + do_bench_buf1_buf1(mimic_bench_adler32, tc_src, &checksum_pi_gt, 0, 0, 3000); } void bench_mimic_crc32_10k() { proc_funcname = __func__; - do_bench_buf1_buf1(mimic_crc32, tc_src, &checksum_midsummer_gt, 0, 0, 30000); + do_bench_buf1_buf1(mimic_bench_crc32, tc_src, &checksum_midsummer_gt, 0, 0, + 30000); } void bench_mimic_crc32_100k() { proc_funcname = __func__; - do_bench_buf1_buf1(mimic_crc32, tc_src, &checksum_pi_gt, 0, 0, 3000); + do_bench_buf1_buf1(mimic_bench_crc32, tc_src, &checksum_pi_gt, 0, 0, 3000); } void bench_mimic_flate_decode_1k() { @@ -712,6 +805,7 @@ void bench_mimic_zlib_decode_100k() { // The empty comments forces clang-format to place one element per line. proc tests[] = { // Flate Tests + test_puffs_adler32, // test_puffs_flate_decode_256_bytes, // test_puffs_flate_decode_midsummer, // test_puffs_flate_decode_pi, // @@ -748,6 +842,8 @@ proc tests[] = { // The empty comments forces clang-format to place one element per line. proc benches[] = { // Flate Benches + bench_puffs_adler32_10k, // + bench_puffs_adler32_100k, // bench_puffs_flate_decode_1k, // bench_puffs_flate_decode_10k, // bench_puffs_flate_decode_100k, //