Commit d098e212ad9b18cd0f74b19dea0f4f3b11092dca | zig

author	Jay Petacat <jay@jayschwa.net> 2020-02-02 14:08:10-05:00
committer	Jay Petacat <jay@jayschwa.net> 2020-02-02 14:08:10-05:00
log	d098e212ad9b18cd0f74b19dea0f4f3b11092dca
tree	d8b692cee926f928af06d27ad9e08f384567185f
parent	4b86c1e3bbe65b8caa9c2e769af633fa8825bb94

blake3: Convert `*const [n]u8` types to `[n]u8`

I do not see many cases of constant pointers to arrays in the stdlib.
In fact, this makes the code run a little faster, probably because Zig
automatically converts to pointers where it makes sense.

1 files changed, 19 insertions(+), 19 deletions(-)

lib
- std
  - crypto
    blake3.zig

lib/std/crypto/blake3.zig+19-19

...	...	@@ -70,7 +70,7 @@ fn g(state: *[16]u32, a: usize, b: usize, c: usize, d: usize, mx: u32, my: u32)
70	70	state[b] = math.rotr(u32, state[b] ^ state[c], 7);
71	71	}
72	72
73		fn round(state: [16]u32, msg: const [16]u32, schedule: *const [16]u8) void {
	73	fn round(state: *[16]u32, msg: [16]u32, schedule: [16]u8) void {
74	74	// Mix the columns.
75	75	g(state, 0, 4, 8, 12, msg[schedule[0]], msg[schedule[1]]);
76	76	g(state, 1, 5, 9, 13, msg[schedule[2]], msg[schedule[3]]);
...	...	@@ -85,8 +85,8 @@ fn round(state: [16]u32, msg: const [16]u32, schedule: *const [16]u8) void {
85	85	}
86	86
87	87	fn compress(
88		chaining_value: *const [8]u32,
89		block_words: *const [16]u32,
	88	chaining_value: [8]u32,
	89	block_words: [16]u32,
90	90	block_len: u32,
91	91	counter: u64,
92	92	flags: u8,
...	...	@@ -109,7 +109,7 @@ fn compress(
109	109	block_len,
110	110	flags,
111	111	};
112		for (MSG_SCHEDULE) \|*schedule\| {
	112	for (MSG_SCHEDULE) \|schedule\| {
113	113	round(&state, block_words, schedule);
114	114	}
115	115	for (chaining_value) \|_, i\| {
...	...	@@ -143,8 +143,8 @@ const Output = struct {
143	143
144	144	fn chaining_value(self: *Output) [8]u32 {
145	145	return first_8_words(compress(
146		&self.input_chaining_value,
147		&self.block_words,
	146	self.input_chaining_value,
	147	self.block_words,
148	148	self.block_len,
149	149	self.counter,
150	150	self.flags,
...	...	@@ -156,8 +156,8 @@ const Output = struct {
156	156	var output_block_counter: usize = 0;
157	157	while (out_block_it.next()) \|out_block\| {
158	158	var words = compress(
159		&self.input_chaining_value,
160		&self.block_words,
	159	self.input_chaining_value,
	160	self.block_words,
161	161	self.block_len,
162	162	output_block_counter,
163	163	self.flags \| ROOT,
...	...	@@ -216,8 +216,8 @@ const ChunkState = struct {
216	216	var block_words: [16]u32 = undefined;
217	217	words_from_little_endian_bytes(&self.block, &block_words);
218	218	self.chaining_value = first_8_words(compress(
219		&self.chaining_value,
220		&block_words,
	219	self.chaining_value,
	220	block_words,
221	221	BLOCK_LEN,
222	222	self.chunk_counter,
223	223	self.flags \| self.start_flag(),
...	...	@@ -232,7 +232,7 @@ const ChunkState = struct {
232	232	}
233	233	}
234	234
235		fn output(self: *ChunkState) Output {
	235	fn output(self: *const ChunkState) Output {
236	236	var block_words: [16]u32 = undefined;
237	237	words_from_little_endian_bytes(&self.block, &block_words);
238	238	return Output{
...	...	@@ -297,9 +297,9 @@ pub const Blake3 = struct {
297	297	}
298	298
299	299	/// Construct a new `Blake3` for the keyed hash function.
300		pub fn init_keyed(key: *const [KEY_LEN]u8) Blake3 {
	300	pub fn init_keyed(key: [KEY_LEN]u8) Blake3 {
301	301	var key_words: [8]u32 = undefined;
302		words_from_little_endian_bytes(key, &key_words);
	302	words_from_little_endian_bytes(key[0..], &key_words);
303	303	return Blake3.init_internal(key_words, KEYED_HASH);
304	304	}
305	305
...	...	@@ -550,7 +550,7 @@ const reference_test = .{
550	550	},
551	551	};
552	552
553		fn test_blake3(hasher: Blake3, input_len: usize, expected_hex: const [262]u8) void {
	553	fn test_blake3(hasher: *Blake3, input_len: usize, expected_hex: [262]u8) void {
554	554	// Setup input pattern
555	555	var input_pattern: [251]u8 = undefined;
556	556	for (input_pattern) \|e, i\| e. = @truncate(u8, i);
...	...	@@ -570,18 +570,18 @@ fn test_blake3(hasher: Blake3, input_len: usize, expected_hex: const [262]u8)
570	570
571	571	// Compare to expected value
572	572	var expected_bytes: [expected_hex.len / 2]u8 = undefined;
573		fmt.hexToBytes(expected_bytes[0..], expected_hex) catch unreachable;
	573	fmt.hexToBytes(expected_bytes[0..], expected_hex[0..]) catch unreachable;
574	574	testing.expectEqual(actual_bytes, expected_bytes);
575	575	}
576	576
577	577	test "BLAKE3 reference test cases" {
578	578	var hash = &Blake3.init();
579		var keyed_hash = &Blake3.init_keyed(reference_test.key);
	579	var keyed_hash = &Blake3.init_keyed(reference_test.key.*);
580	580	var derive_key = &Blake3.init_derive_key(reference_test.context_string);
581	581
582	582	for (reference_test.cases) \|t\| {
583		test_blake3(hash, t.input_len, t.hash);
584		test_blake3(keyed_hash, t.input_len, t.keyed_hash);
585		test_blake3(derive_key, t.input_len, t.derive_key);
	583	test_blake3(hash, t.input_len, t.hash.*);
	584	test_blake3(keyed_hash, t.input_len, t.keyed_hash.*);
	585	test_blake3(derive_key, t.input_len, t.derive_key.*);
586	586	}
587	587	}