std: add hasher_u32 update!, checksum_u32 methods

This commit is contained in:
Nigel Tao committed 2023-10-05 19:27:02 +11:00
1 parent b5eee6ac4f
commit 80b1988237
7 files changed
+299 -25

No files matched your search

+1
View File
@@ -6,6 +6,7 @@
- Added `compact_retaining` and `history_retain_length`.
- Added `example/toy-aux-image`.
- Added `get_quirk(key: u32) u64`.
- Added `hasher_u32` `update!` and `checksum_u32` methods
- Added `if.likely` and `if.unlikely`.
- Added `slice_var as nptr array[etc] etc` conversion.
- Added `std/jpeg`.
+2
View File
@@ -23,8 +23,10 @@ resist timing attacks.
In Wuffs syntax, the `base.hasher_u32` methods are:
- `checksum_u32() u32`
- `get_quirk(key: u32) u64`
- `set_quirk!(key: u32, value: u64) status`
- `update!(x: slice u8)`
- `update_u32!(x: slice u8) u32`
+2
View File
@@ -956,8 +956,10 @@ var InterfacesMap = map[string]bool{
var InterfaceFuncs = []string{
// ---- hasher_u32
"hasher_u32.checksum_u32() u32",
"hasher_u32.get_quirk(key: u32) u64",
"hasher_u32.set_quirk!(key: u32, value: u64) status",
"hasher_u32.update!(x: roslice u8)",
"hasher_u32.update_u32!(x: roslice u8) u32",
// ---- image_decoder
+271 -21
View File
@@ -6000,6 +6000,8 @@ wuffs_base__ascii__longest_valid_prefix(const uint8_t* s_ptr, size_t s_len);
extern const char wuffs_base__hasher_u32__vtable_name[];
typedef struct wuffs_base__hasher_u32__func_ptrs__struct {
uint32_t (*checksum_u32)(
const void* self);
uint64_t (*get_quirk)(
const void* self,
uint32_t a_key);
@@ -6007,6 +6009,9 @@ typedef struct wuffs_base__hasher_u32__func_ptrs__struct {
void* self,
uint32_t a_key,
uint64_t a_value);
wuffs_base__empty_struct (*update)(
void* self,
wuffs_base__slice_u8 a_x);
uint32_t (*update_u32)(
void* self,
wuffs_base__slice_u8 a_x);
@@ -6014,6 +6019,11 @@ typedef struct wuffs_base__hasher_u32__func_ptrs__struct {
typedef struct wuffs_base__hasher_u32__struct wuffs_base__hasher_u32;
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint32_t
wuffs_base__hasher_u32__checksum_u32(
const wuffs_base__hasher_u32* self);
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint64_t
wuffs_base__hasher_u32__get_quirk(
@@ -6027,6 +6037,12 @@ wuffs_base__hasher_u32__set_quirk(
uint32_t a_key,
uint64_t a_value);
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct
wuffs_base__hasher_u32__update(
wuffs_base__hasher_u32* self,
wuffs_base__slice_u8 a_x);
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint32_t
wuffs_base__hasher_u32__update_u32(
@@ -6047,6 +6063,11 @@ struct wuffs_base__hasher_u32__struct {
using unique_ptr = std::unique_ptr<wuffs_base__hasher_u32, wuffs_unique_ptr_deleter>;
#endif
inline uint32_t
checksum_u32() const {
return wuffs_base__hasher_u32__checksum_u32(this);
}
inline uint64_t
get_quirk(
uint32_t a_key) const {
@@ -6062,6 +6083,13 @@ struct wuffs_base__hasher_u32__struct {
this, a_key, a_value);
}
inline wuffs_base__empty_struct
update(
wuffs_base__slice_u8 a_x) {
return wuffs_base__hasher_u32__update(
this, a_x);
}
inline uint32_t
update_u32(
wuffs_base__slice_u8 a_x) {
@@ -6630,12 +6658,23 @@ wuffs_adler32__hasher__set_quirk(
uint32_t a_key,
uint64_t a_value);
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct
wuffs_adler32__hasher__update(
wuffs_adler32__hasher* self,
wuffs_base__slice_u8 a_x);
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint32_t
wuffs_adler32__hasher__update_u32(
wuffs_adler32__hasher* self,
wuffs_base__slice_u8 a_x);
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint32_t
wuffs_adler32__hasher__checksum_u32(
const wuffs_adler32__hasher* self);
#ifdef __cplusplus
} // extern "C"
#endif
@@ -6746,12 +6785,23 @@ struct wuffs_adler32__hasher__struct {
return wuffs_adler32__hasher__set_quirk(this, a_key, a_value);
}
inline wuffs_base__empty_struct
update(
wuffs_base__slice_u8 a_x) {
return wuffs_adler32__hasher__update(this, a_x);
}
inline uint32_t
update_u32(
wuffs_base__slice_u8 a_x) {
return wuffs_adler32__hasher__update_u32(this, a_x);
}
inline uint32_t
checksum_u32() const {
return wuffs_adler32__hasher__checksum_u32(this);
}
#endif // __cplusplus
}; // struct wuffs_adler32__hasher__struct
@@ -7776,12 +7826,23 @@ wuffs_crc32__ieee_hasher__set_quirk(
uint32_t a_key,
uint64_t a_value);
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct
wuffs_crc32__ieee_hasher__update(
wuffs_crc32__ieee_hasher* self,
wuffs_base__slice_u8 a_x);
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint32_t
wuffs_crc32__ieee_hasher__update_u32(
wuffs_crc32__ieee_hasher* self,
wuffs_base__slice_u8 a_x);
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint32_t
wuffs_crc32__ieee_hasher__checksum_u32(
const wuffs_crc32__ieee_hasher* self);
#ifdef __cplusplus
} // extern "C"
#endif
@@ -7891,12 +7952,23 @@ struct wuffs_crc32__ieee_hasher__struct {
return wuffs_crc32__ieee_hasher__set_quirk(this, a_key, a_value);
}
inline wuffs_base__empty_struct
update(
wuffs_base__slice_u8 a_x) {
return wuffs_crc32__ieee_hasher__update(this, a_x);
}
inline uint32_t
update_u32(
wuffs_base__slice_u8 a_x) {
return wuffs_crc32__ieee_hasher__update_u32(this, a_x);
}
inline uint32_t
checksum_u32() const {
return wuffs_crc32__ieee_hasher__checksum_u32(this);
}
#endif // __cplusplus
}; // struct wuffs_crc32__ieee_hasher__struct
@@ -12338,12 +12410,23 @@ wuffs_xxhash32__hasher__set_quirk(
uint32_t a_key,
uint64_t a_value);
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct
wuffs_xxhash32__hasher__update(
wuffs_xxhash32__hasher* self,
wuffs_base__slice_u8 a_x);
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint32_t
wuffs_xxhash32__hasher__update_u32(
wuffs_xxhash32__hasher* self,
wuffs_base__slice_u8 a_x);
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint32_t
wuffs_xxhash32__hasher__checksum_u32(
const wuffs_xxhash32__hasher* self);
#ifdef __cplusplus
} // extern "C"
#endif
@@ -12458,12 +12541,23 @@ struct wuffs_xxhash32__hasher__struct {
return wuffs_xxhash32__hasher__set_quirk(this, a_key, a_value);
}
inline wuffs_base__empty_struct
update(
wuffs_base__slice_u8 a_x) {
return wuffs_xxhash32__hasher__update(this, a_x);
}
inline uint32_t
update_u32(
wuffs_base__slice_u8 a_x) {
return wuffs_xxhash32__hasher__update_u32(this, a_x);
}
inline uint32_t
checksum_u32() const {
return wuffs_xxhash32__hasher__checksum_u32(this);
}
#endif // __cplusplus
}; // struct wuffs_xxhash32__hasher__struct
@@ -14013,6 +14107,34 @@ const char wuffs_base__token_decoder__vtable_name[] = "{vtable}wuffs_base__token
// ---------------- Interface Definitions.
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint32_t
wuffs_base__hasher_u32__checksum_u32(
const wuffs_base__hasher_u32* self) {
if (!self) {
return 0;
}
if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
(self->private_impl.magic != WUFFS_BASE__DISABLED)) {
return 0;
}
const wuffs_base__vtable* v = &self->private_impl.first_vtable;
int i;
for (i = 0; i < 63; i++) {
if (v->vtable_name == wuffs_base__hasher_u32__vtable_name) {
const wuffs_base__hasher_u32__func_ptrs* func_ptrs =
(const wuffs_base__hasher_u32__func_ptrs*)(v->function_pointers);
return (*func_ptrs->checksum_u32)(self);
} else if (v->vtable_name == NULL) {
break;
}
v++;
}
return 0;
}
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint64_t
wuffs_base__hasher_u32__get_quirk(
@@ -14074,6 +14196,34 @@ wuffs_base__hasher_u32__set_quirk(
return wuffs_base__make_status(wuffs_base__error__bad_vtable);
}
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct
wuffs_base__hasher_u32__update(
wuffs_base__hasher_u32* self,
wuffs_base__slice_u8 a_x) {
if (!self) {
return wuffs_base__make_empty_struct();
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
return wuffs_base__make_empty_struct();
}
const wuffs_base__vtable* v = &self->private_impl.first_vtable;
int i;
for (i = 0; i < 63; i++) {
if (v->vtable_name == wuffs_base__hasher_u32__vtable_name) {
const wuffs_base__hasher_u32__func_ptrs* func_ptrs =
(const wuffs_base__hasher_u32__func_ptrs*)(v->function_pointers);
return (*func_ptrs->update)(self, a_x);
} else if (v->vtable_name == NULL) {
break;
}
v++;
}
return wuffs_base__make_empty_struct();
}
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint32_t
wuffs_base__hasher_u32__update_u32(
@@ -26492,11 +26642,14 @@ wuffs_adler32__hasher__up_x86_sse42(
const wuffs_base__hasher_u32__func_ptrs
wuffs_adler32__hasher__func_ptrs_for__wuffs_base__hasher_u32 = {
(uint32_t(*)(const void*))(&wuffs_adler32__hasher__checksum_u32),
(uint64_t(*)(const void*,
uint32_t))(&wuffs_adler32__hasher__get_quirk),
(wuffs_base__status(*)(void*,
uint32_t,
uint64_t))(&wuffs_adler32__hasher__set_quirk),
(wuffs_base__empty_struct(*)(void*,
wuffs_base__slice_u8))(&wuffs_adler32__hasher__update),
(uint32_t(*)(void*,
wuffs_base__slice_u8))(&wuffs_adler32__hasher__update_u32),
};
@@ -26613,18 +26766,18 @@ wuffs_adler32__hasher__set_quirk(
return wuffs_base__make_status(wuffs_base__error__unsupported_option);
}
// -------- func adler32.hasher.update_u32
// -------- func adler32.hasher.update
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint32_t
wuffs_adler32__hasher__update_u32(
WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct
wuffs_adler32__hasher__update(
wuffs_adler32__hasher* self,
wuffs_base__slice_u8 a_x) {
if (!self) {
return 0;
return wuffs_base__make_empty_struct();
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
return 0;
return wuffs_base__make_empty_struct();
}
if ( ! self->private_impl.f_started) {
@@ -26640,6 +26793,24 @@ wuffs_adler32__hasher__update_u32(
self->private_impl.choosy_up);
}
wuffs_adler32__hasher__up(self, a_x);
return wuffs_base__make_empty_struct();
}
// -------- func adler32.hasher.update_u32
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint32_t
wuffs_adler32__hasher__update_u32(
wuffs_adler32__hasher* self,
wuffs_base__slice_u8 a_x) {
if (!self) {
return 0;
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
return 0;
}
wuffs_adler32__hasher__update(self, a_x);
return self->private_impl.f_state;
}
@@ -26719,6 +26890,23 @@ wuffs_adler32__hasher__up__choosy_default(
return wuffs_base__make_empty_struct();
}
// -------- func adler32.hasher.checksum_u32
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint32_t
wuffs_adler32__hasher__checksum_u32(
const wuffs_adler32__hasher* self) {
if (!self) {
return 0;
}
if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
(self->private_impl.magic != WUFFS_BASE__DISABLED)) {
return 0;
}
return self->private_impl.f_state;
}
// ‼ WUFFS MULTI-FILE SECTION +arm_neon
// -------- func adler32.hasher.up_arm_neon
@@ -32760,11 +32948,14 @@ wuffs_crc32__ieee_hasher__up_x86_sse42(
const wuffs_base__hasher_u32__func_ptrs
wuffs_crc32__ieee_hasher__func_ptrs_for__wuffs_base__hasher_u32 = {
(uint32_t(*)(const void*))(&wuffs_crc32__ieee_hasher__checksum_u32),
(uint64_t(*)(const void*,
uint32_t))(&wuffs_crc32__ieee_hasher__get_quirk),
(wuffs_base__status(*)(void*,
uint32_t,
uint64_t))(&wuffs_crc32__ieee_hasher__set_quirk),
(wuffs_base__empty_struct(*)(void*,
wuffs_base__slice_u8))(&wuffs_crc32__ieee_hasher__update),
(uint32_t(*)(void*,
wuffs_base__slice_u8))(&wuffs_crc32__ieee_hasher__update_u32),
};
@@ -32881,18 +33072,18 @@ wuffs_crc32__ieee_hasher__set_quirk(
return wuffs_base__make_status(wuffs_base__error__unsupported_option);
}
// -------- func crc32.ieee_hasher.update_u32
// -------- func crc32.ieee_hasher.update
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint32_t
wuffs_crc32__ieee_hasher__update_u32(
WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct
wuffs_crc32__ieee_hasher__update(
wuffs_crc32__ieee_hasher* self,
wuffs_base__slice_u8 a_x) {
if (!self) {
return 0;
return wuffs_base__make_empty_struct();
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
return 0;
return wuffs_base__make_empty_struct();
}
if (self->private_impl.f_state == 0u) {
@@ -32909,6 +33100,24 @@ wuffs_crc32__ieee_hasher__update_u32(
self->private_impl.choosy_up);
}
wuffs_crc32__ieee_hasher__up(self, a_x);
return wuffs_base__make_empty_struct();
}
// -------- func crc32.ieee_hasher.update_u32
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint32_t
wuffs_crc32__ieee_hasher__update_u32(
wuffs_crc32__ieee_hasher* self,
wuffs_base__slice_u8 a_x) {
if (!self) {
return 0;
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
return 0;
}
wuffs_crc32__ieee_hasher__update(self, a_x);
return self->private_impl.f_state;
}
@@ -33017,6 +33226,23 @@ wuffs_crc32__ieee_hasher__up__choosy_default(
return wuffs_base__make_empty_struct();
}
// -------- func crc32.ieee_hasher.checksum_u32
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint32_t
wuffs_crc32__ieee_hasher__checksum_u32(
const wuffs_crc32__ieee_hasher* self) {
if (!self) {
return 0;
}
if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
(self->private_impl.magic != WUFFS_BASE__DISABLED)) {
return 0;
}
return self->private_impl.f_state;
}
// ‼ WUFFS MULTI-FILE SECTION +arm_crc32
// -------- func crc32.ieee_hasher.up_arm_crc32
@@ -60726,20 +60952,18 @@ wuffs_xxhash32__hasher__up(
wuffs_xxhash32__hasher* self,
wuffs_base__slice_u8 a_x);
WUFFS_BASE__GENERATED_C_CODE
static uint32_t
wuffs_xxhash32__hasher__checksum_u32(
const wuffs_xxhash32__hasher* self);
// ---------------- VTables
const wuffs_base__hasher_u32__func_ptrs
wuffs_xxhash32__hasher__func_ptrs_for__wuffs_base__hasher_u32 = {
(uint32_t(*)(const void*))(&wuffs_xxhash32__hasher__checksum_u32),
(uint64_t(*)(const void*,
uint32_t))(&wuffs_xxhash32__hasher__get_quirk),
(wuffs_base__status(*)(void*,
uint32_t,
uint64_t))(&wuffs_xxhash32__hasher__set_quirk),
(wuffs_base__empty_struct(*)(void*,
wuffs_base__slice_u8))(&wuffs_xxhash32__hasher__update),
(uint32_t(*)(void*,
wuffs_base__slice_u8))(&wuffs_xxhash32__hasher__update_u32),
};
@@ -60854,18 +61078,18 @@ wuffs_xxhash32__hasher__set_quirk(
return wuffs_base__make_status(wuffs_base__error__unsupported_option);
}
// -------- func xxhash32.hasher.update_u32
// -------- func xxhash32.hasher.update
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint32_t
wuffs_xxhash32__hasher__update_u32(
WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct
wuffs_xxhash32__hasher__update(
wuffs_xxhash32__hasher* self,
wuffs_base__slice_u8 a_x) {
if (!self) {
return 0;
return wuffs_base__make_empty_struct();
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
return 0;
return wuffs_base__make_empty_struct();
}
wuffs_base__slice_u8 v_remaining = {0};
@@ -60885,6 +61109,24 @@ wuffs_xxhash32__hasher__update_u32(
wuffs_xxhash32__hasher__up(self, a_x);
a_x = v_remaining;
}
return wuffs_base__make_empty_struct();
}
// -------- func xxhash32.hasher.update_u32
WUFFS_BASE__GENERATED_C_CODE
WUFFS_BASE__MAYBE_STATIC uint32_t
wuffs_xxhash32__hasher__update_u32(
wuffs_xxhash32__hasher* self,
wuffs_base__slice_u8 a_x) {
if (!self) {
return 0;
}
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
return 0;
}
wuffs_xxhash32__hasher__update(self, a_x);
return wuffs_xxhash32__hasher__checksum_u32(self);
}
@@ -61015,9 +61257,17 @@ wuffs_xxhash32__hasher__up(
// -------- func xxhash32.hasher.checksum_u32
WUFFS_BASE__GENERATED_C_CODE
static uint32_t
WUFFS_BASE__MAYBE_STATIC uint32_t
wuffs_xxhash32__hasher__checksum_u32(
const wuffs_xxhash32__hasher* self) {
if (!self) {
return 0;
}
if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
(self->private_impl.magic != WUFFS_BASE__DISABLED)) {
return 0;
}
uint32_t v_ret = 0;
uint32_t v_i = 0;
uint32_t v_n = 0;
+9 -1
View File
@@ -26,7 +26,7 @@ pub func hasher.set_quirk!(key: base.u32, value: base.u64) base.status {
return base."#unsupported option"
}
pub func hasher.update_u32!(x: roslice base.u8) base.u32 {
pub func hasher.update!(x: roslice base.u8) {
if not this.started {
this.started = true
this.state = 1
@@ -39,6 +39,10 @@ pub func hasher.update_u32!(x: roslice base.u8) base.u32 {
up_x86_sse42]
}
this.up!(x: args.x)
}
pub func hasher.update_u32!(x: roslice base.u8) base.u32 {
this.update!(x: args.x)
return this.state
}
@@ -74,3 +78,7 @@ pri func hasher.up!(x: roslice base.u8),
} endwhile
this.state = ((s2 & 0xFFFF) << 16) | (s1 & 0xFFFF)
}
pub func hasher.checksum_u32() base.u32 {
return this.state
}
+9 -1
View File
@@ -28,7 +28,7 @@ pub func ieee_hasher.set_quirk!(key: base.u32, value: base.u64) base.status {
// TODO: should it be ? instead of ! because it's public, and might need a way
// to signal "initializer not called"? Should the return type, in the generated
// C code, be "struct{ uint32_t checksum; wuffs_crc32__status status }"?
pub func ieee_hasher.update_u32!(x: roslice base.u8) base.u32 {
pub func ieee_hasher.update!(x: roslice base.u8) {
if this.state == 0 {
choose up = [
up_arm_crc32,
@@ -36,6 +36,10 @@ pub func ieee_hasher.update_u32!(x: roslice base.u8) base.u32 {
up_x86_sse42]
}
this.up!(x: args.x)
}
pub func ieee_hasher.update_u32!(x: roslice base.u8) base.u32 {
this.update!(x: args.x)
return this.state
}
@@ -77,6 +81,10 @@ pri func ieee_hasher.up!(x: roslice base.u8),
this.state = 0xFFFF_FFFF ^ s
}
pub func ieee_hasher.checksum_u32() base.u32 {
return this.state
}
// The table below was created by script/print-crc32-magic-numbers.go.
pri const IEEE_TABLE : roarray[16] roarray[256] base.u32 = [[
+5 -2
View File
@@ -47,7 +47,7 @@ pub func hasher.set_quirk!(key: base.u32, value: base.u64) base.status {
return base."#unsupported option"
}
pub func hasher.update_u32!(x: roslice base.u8) base.u32 {
pub func hasher.update!(x: roslice base.u8) {
var remaining : roslice base.u8
if (this.length_modulo_u32 == 0) and not this.length_overflows_u32 {
@@ -68,7 +68,10 @@ pub func hasher.update_u32!(x: roslice base.u8) base.u32 {
args.x = remaining
} endwhile
}
pub func hasher.update_u32!(x: roslice base.u8) base.u32 {
this.update!(x: args.x)
return this.checksum_u32()
}
@@ -183,7 +186,7 @@ pri func hasher.up!(x: roslice base.u8) {
this.v3 = v3
}
pri func hasher.checksum_u32() base.u32 {
pub func hasher.checksum_u32() base.u32 {
var ret : base.u32
var i : base.u32[..= 16]
var n : base.u32[..= 16]