refactor: replace x_decode function by a generic MACRO

include/decode.h

@@ -0,0 +1,23 @@
+/* Generic decode macro:
+ * DECODE_GENERIC(block, dest, count, bytes, type, is_big_endian)
+ * - block: uint8_t array pointer
+ * - dest: destination array (type[])
+ * - count: number of words
+ * - bytes: bytes per word (e.g., 4 or 8)
+ * - type: integer type (e.g., uint32_t, uint64_t)
+ * - is_big_endian: 1 for big-endian decode, 0 for little-endian decode
+ */
+#define DECODE_GENERIC(block, dest, count, bytes, type, is_big_endian)				\
+	do {																			\
+		for (size_t _i = 0; _i < (count); ++_i) {									\
+			const size_t _off = _i * (bytes);										\
+			(dest)[_i] = (type)0;													\
+			if (is_big_endian) {													\
+				for (size_t _b = 0; _b < (bytes); ++_b)								\
+				(dest)[_i] |= (type)(block[_off + _b]) << (8 * ((bytes) - 1 - _b)); \
+			} else {																\
+				for (size_t _b = 0; _b < (bytes); ++_b)								\
+				(dest)[_i] |= (type)(block[_off + _b]) << (8 * _b);					\
+			}																		\
+		}																			\
+	} while (0)

src/md5/md5_compress.c

@@ -1,4 +1,5 @@
 #include "md5_internal.h"
+#include "decode.h"
 #include <stdint.h>
 
 /* Forward declrations */
@@ -14,7 +15,6 @@ static uint32_t	md5_k1(uint8_t i);
 static uint32_t	md5_k2(uint8_t i);
 static uint32_t	md5_k3(uint8_t i);
 static uint32_t	md5_leftrotate(uint32_t x, uint32_t n);
-static void		md5_decode(const uint8_t block[64], uint32_t m[16]);
 /* ------------------- */
 
 static const md5_round_fn	round_fns[4] = { md5_f, md5_g, md5_h, md5_i };
@@ -27,7 +27,7 @@ md5_compress(struct md5_ctx *ctx, const uint8_t block[64])
 	uint32_t	a, b, c, d;
 	uint32_t	temp;
 
-	md5_decode(block, m);
+	DECODE_GENERIC(block, m, 16, 4, uint32_t, 0);
 
 	a = ctx->state[0];
 	b = ctx->state[1];
@@ -50,22 +50,6 @@ md5_compress(struct md5_ctx *ctx, const uint8_t block[64])
 	ctx->state[3] += d;
 }
 
-
-/* Decode 64 bytes into 16 x uint32_t words (little-endian) */
-static void
-md5_decode(const uint8_t block[64], uint32_t m[16])
-{
-	for (uint8_t i = 0; i < 16; ++i)
-	{
-		const uint8_t	i4 = i * 4;
-
-		m[i] = (uint32_t)block[i4 + 0] << 0
-			 | (uint32_t)block[i4 + 1] << 8
-			 | (uint32_t)block[i4 + 2] << 16
-			 | (uint32_t)block[i4 + 3] << 24;
-	}
-}
-
 /* Round functions */
 static uint32_t
 md5_f(uint32_t b, uint32_t c, uint32_t d)

src/sha256/sha256_compress.c

@@ -1,5 +1,6 @@
 #include "sha256.h"
 #include "sha256_internal.h"
+#include "decode.h"
 #include <stdint.h>
 
 /* Forward declarations */
@@ -10,7 +11,6 @@ static uint32_t	sha256_Sigma0(uint32_t x);
 static uint32_t	sha256_Sigma1(uint32_t x);
 static uint32_t	sha256_sigma0(uint32_t x);
 static uint32_t	sha256_sigma1(uint32_t x);
-static void		sha256_decode(const uint8_t block[64], uint32_t w[16]);
 static void		sha256_schedule(uint32_t w[64], const uint8_t block[64]);
 static void		sha256_rounds(uint32_t state[8], const uint32_t w[64]);
 /* ------------- */
@@ -27,7 +27,7 @@ sha256_compress(struct sha256_ctx *ctx, const uint8_t block[64])
 static void
 sha256_schedule(uint32_t w[64], const uint8_t block[64])
 {
-	sha256_decode(block, w);
+	DECODE_GENERIC(block, w, 16, 4, uint32_t, 1);
 
 	for (uint8_t i = 16; i < 64; ++i)
 	{
@@ -72,21 +72,6 @@ sha256_rounds(uint32_t state[8], const uint32_t w[64])
 	state[7] += h;
 }
 
-/* Decode 64 bytes into 16 x uint32_t words (big-endian) */
-static void
-sha256_decode(const uint8_t block[64], uint32_t w[16])
-{
-	for (uint8_t i = 0; i < 16; ++i)
-	{
-		const uint8_t	i4 = i * 4;
-
-		w[i] = (uint32_t)block[i4 + 0] << 24
-			 | (uint32_t)block[i4 + 1] << 16
-			 | (uint32_t)block[i4 + 2] << 8
-			 | (uint32_t)block[i4 + 3] << 0;
-	}
-}
-
 static uint32_t
 sha256_rotr(uint32_t x, uint32_t n)
 {

src/whirlpool/whirlpool_compress.c

@@ -1,4 +1,5 @@
 #include "whirlpool_internal.h"
+#include "decode.h"
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
@@ -10,7 +11,6 @@ static void				sub_bytes(uint64_t state[8]);
 static void				shift_columns(uint64_t state[8]);
 static void				mix_rows(uint64_t state[8]);
 static inline void		add_round_key(uint64_t state[8], const uint64_t key[8]);
-static void				decode_block(const uint8_t block[64], uint64_t W[8]);
 static void				round_function(uint64_t state[8], const uint64_t
 		key[8]);
 /* ---------------- */
@@ -21,7 +21,7 @@ void	whirlpool_compress(struct whirlpool_ctx *ctx, const uint8_t block[64])
 	uint64_t L[8];
 	uint64_t K[11][8];
 
-	decode_block(block, W);
+	DECODE_GENERIC(block, W, 8, 8, uint64_t, 1);
 
 	memcpy(K[0], ctx->state, sizeof(ctx->state));
 
@@ -51,23 +51,6 @@ round_function(uint64_t state[8], const uint64_t key[8])
 	add_round_key(state, key);
 }
 
-static void
-decode_block(const uint8_t block[64], uint64_t W[8])
-{
-	for (uint8_t i = 0; i < 8; ++i)
-	{
-		const uint8_t i8 = i * 8;
-		W[i] = ((uint64_t)block[i8 + 0] << 56)
-			 | ((uint64_t)block[i8 + 1] << 48)
-			 | ((uint64_t)block[i8 + 2] << 40)
-			 | ((uint64_t)block[i8 + 3] << 32)
-			 | ((uint64_t)block[i8 + 4] << 24)
-			 | ((uint64_t)block[i8 + 5] << 16)
-			 | ((uint64_t)block[i8 + 6] << 8)
-			 | ((uint64_t)block[i8 + 7] << 0);
-	}
-}
-
 static inline uint8_t
 gf_mul2(uint8_t a)
 {