avoid some theoretical aliasing UB

N-R-K · N-R-K · commit 7159bfafc656 · 2026-04-21T21:24:05.000Z
in theory, uint8_t is an integer type which does not benefit from the same luxury as character types in terms of being able to freely alias other types. in practice, it's a typedef to `unsigned char` and so it works out. i've mostly been actively ignoring this part of the standard since (A) `uint8_t` often better reflects the intent, in this case we expect 8 bit octets not a fuzzy "character" type and (B) implementing such optimization would break lot of real world code and should realistically be considered malicious (not that it has stopped gcc/clang from implementing nonsense/dangerous optimizations). the README does make claim of being UB free, so i'll just update the code to match the document. Thanks to Michael Forney for reporting. Ref: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66110
diff --git a/chibihash64-stream.h b/chibihash64-stream.h
@@ -24,12 +24,12 @@ typedef struct {
 
 // hacky way to make both chibihash64.h and chibihash64-stream.h usable within same TU
 #if !defined(CHIBIHASH64__HGUARD)
-static inline uint64_t chibihash64__load32le(const uint8_t *p)
+static inline uint64_t chibihash64__load32le(const unsigned char *p)
 {
 	return (uint64_t)p[0] <<  0 | (uint64_t)p[1] <<  8 |
 	       (uint64_t)p[2] << 16 | (uint64_t)p[3] << 24;
 }
-static inline uint64_t chibihash64__load64le(const uint8_t *p)
+static inline uint64_t chibihash64__load64le(const unsigned char *p)
 {
 	return chibihash64__load32le(p) | (chibihash64__load32le(p+4) << 32);
 }
@@ -46,7 +46,7 @@ static inline uint64_t chibihash64__rotl(uint64_t x, int n)
 #endif
 
 static inline void
-chibihash64__stream_block(uint64_t h[4], const uint8_t *p)
+chibihash64__stream_block(uint64_t h[4], const unsigned char *p)
 {
 	const uint64_t K = UINT64_C(0x2B7E151628AED2A7);
 	for (int i = 0; i < 4; ++i, p += 8) {
@@ -73,7 +73,7 @@ chibihash64_init(uint64_t seed)
 static inline void
 chibihash64_append(ChibiHash64Ctx *ctx, void *keyIn, ptrdiff_t len)
 {
-	const uint8_t *p = (const uint8_t *)keyIn;
+	const unsigned char *p = (const unsigned char *)keyIn;
 	ptrdiff_t l = len;
 
 	ctx->total_len += len;
diff --git a/chibihash64.h b/chibihash64.h
@@ -9,12 +9,12 @@
 #include <stdint.h>
 #include <stddef.h>
 
-static inline uint64_t chibihash64__load32le(const uint8_t *p)
+static inline uint64_t chibihash64__load32le(const unsigned char *p)
 {
 	return (uint64_t)p[0] <<  0 | (uint64_t)p[1] <<  8 |
 	       (uint64_t)p[2] << 16 | (uint64_t)p[3] << 24;
 }
-static inline uint64_t chibihash64__load64le(const uint8_t *p)
+static inline uint64_t chibihash64__load64le(const unsigned char *p)
 {
 	return chibihash64__load32le(p) | (chibihash64__load32le(p+4) << 32);
 }
@@ -26,7 +26,7 @@ static inline uint64_t chibihash64__rotl(uint64_t x, int n)
 static inline uint64_t
 chibihash64(const void *keyIn, ptrdiff_t len, uint64_t seed)
 {
-	const uint8_t *p = (const uint8_t *)keyIn;
+	const unsigned char *p = (const unsigned char *)keyIn;
 	ptrdiff_t l = len;
 
 	const uint64_t K = UINT64_C(0x2B7E151628AED2A7); // digits of e

Original file line number	Diff line number	Diff line change
`@@ -24,12 +24,12 @@ typedef struct {`
`24`	`24`
`25`	`25`	`// hacky way to make both chibihash64.h and chibihash64-stream.h usable within same TU`
`26`	`26`	`#if !defined(CHIBIHASH64__HGUARD)`
`27`		`-static inline uint64_t chibihash64__load32le(const uint8_t *p)`
	`27`	`+static inline uint64_t chibihash64__load32le(const unsigned char *p)`
`28`	`28`	`{`
`29`	`29`	`return (uint64_t)p[0] << 0 \| (uint64_t)p[1] << 8 \|`
`30`	`30`	`(uint64_t)p[2] << 16 \| (uint64_t)p[3] << 24;`
`31`	`31`	`}`
`32`		`-static inline uint64_t chibihash64__load64le(const uint8_t *p)`
	`32`	`+static inline uint64_t chibihash64__load64le(const unsigned char *p)`
`33`	`33`	`{`
`34`	`34`	`return chibihash64__load32le(p) \| (chibihash64__load32le(p+4) << 32);`
`35`	`35`	`}`
`@@ -46,7 +46,7 @@ static inline uint64_t chibihash64__rotl(uint64_t x, int n)`
`46`	`46`	`#endif`
`47`	`47`
`48`	`48`	`static inline void`
`49`		`-chibihash64__stream_block(uint64_t h[4], const uint8_t *p)`
	`49`	`+chibihash64__stream_block(uint64_t h[4], const unsigned char *p)`
`50`	`50`	`{`
`51`	`51`	`const uint64_t K = UINT64_C(0x2B7E151628AED2A7);`
`52`	`52`	`for (int i = 0; i < 4; ++i, p += 8) {`
`@@ -73,7 +73,7 @@ chibihash64_init(uint64_t seed)`
`73`	`73`	`static inline void`
`74`	`74`	`chibihash64_append(ChibiHash64Ctx ctx, void keyIn, ptrdiff_t len)`
`75`	`75`	`{`
`76`		`- const uint8_t p = (const uint8_t )keyIn;`
	`76`	`+ const unsigned char p = (const unsigned char )keyIn;`
`77`	`77`	`ptrdiff_t l = len;`
`78`	`78`
`79`	`79`	`ctx->total_len += len;`
Original file line number	Diff line number	Diff line change
`@@ -9,12 +9,12 @@`
`9`	`9`	`#include <stdint.h>`
`10`	`10`	`#include <stddef.h>`
`11`	`11`
`12`		`-static inline uint64_t chibihash64__load32le(const uint8_t *p)`
	`12`	`+static inline uint64_t chibihash64__load32le(const unsigned char *p)`
`13`	`13`	`{`
`14`	`14`	`return (uint64_t)p[0] << 0 \| (uint64_t)p[1] << 8 \|`
`15`	`15`	`(uint64_t)p[2] << 16 \| (uint64_t)p[3] << 24;`
`16`	`16`	`}`
`17`		`-static inline uint64_t chibihash64__load64le(const uint8_t *p)`
	`17`	`+static inline uint64_t chibihash64__load64le(const unsigned char *p)`
`18`	`18`	`{`
`19`	`19`	`return chibihash64__load32le(p) \| (chibihash64__load32le(p+4) << 32);`
`20`	`20`	`}`
`@@ -26,7 +26,7 @@ static inline uint64_t chibihash64__rotl(uint64_t x, int n)`
`26`	`26`	`static inline uint64_t`
`27`	`27`	`chibihash64(const void *keyIn, ptrdiff_t len, uint64_t seed)`
`28`	`28`	`{`
`29`		`- const uint8_t p = (const uint8_t )keyIn;`
	`29`	`+ const unsigned char p = (const unsigned char )keyIn;`
`30`	`30`	`ptrdiff_t l = len;`
`31`	`31`
`32`	`32`	`const uint64_t K = UINT64_C(0x2B7E151628AED2A7); // digits of e`