LLVM: lib/Support/BLAKE3/blake3.c Source File (original) (raw)
1
2
3
4
5
6
7
8
9#include <assert.h>
10#include <stdbool.h>
12
14
16
20 self->chunk_counter = 0;
22 self->buf_len = 0;
23 self->blocks_compressed = 0;
24 self->flags = flags;
25}
26
30 self->chunk_counter = chunk_counter;
31 self->blocks_compressed = 0;
33 self->buf_len = 0;
34}
35
38 ((size_t)self->buf_len);
39}
40
42 const uint8_t *input, size_t input_len) {
44 if (take > input_len) {
45 take = input_len;
46 }
47 uint8_t *dest = self->buf + ((size_t)self->buf_len);
48 memcpy(dest, input, take);
49 self->buf_len += (uint8_t)take;
50 return take;
51}
52
54 if (self->blocks_compressed == 0) {
56 } else {
57 return 0;
58 }
59}
60
68
74 memcpy(ret.input_cv, input_cv, 32);
78 ret.flags = flags;
79 return ret;
80}
81
82
83
84
85
86
87
90 memcpy(cv_words, self->input_cv, 32);
94}
95
97 size_t out_len) {
98 if (out_len == 0) {
99 return;
100 }
101 uint64_t output_block_counter = seek / 64;
102 size_t offset_within_block = seek % 64;
104 if(offset_within_block) {
106 const size_t available_bytes = 64 - offset_within_block;
107 const size_t bytes = out_len > available_bytes ? available_bytes : out_len;
108 memcpy(out, wide_buf + offset_within_block, bytes);
109 out += bytes;
110 out_len -= bytes;
111 output_block_counter += 1;
112 }
113 if(out_len / 64) {
115 }
116 output_block_counter += out_len / 64;
117 out += out_len & -64;
118 out_len -= out_len & -64;
119 if(out_len) {
121 memcpy(out, wide_buf, out_len);
122 }
123}
124
126 size_t input_len) {
127 if (self->buf_len > 0) {
129 input += take;
130 input_len -= take;
131 if (input_len > 0) {
135 self->blocks_compressed += 1;
136 self->buf_len = 0;
138 }
139 }
140
143 self->chunk_counter,
145 self->blocks_compressed += 1;
148 }
149
151}
152
156 return make_output(self->cv, self->buf, self->buf_len, self->chunk_counter,
157 block_flags);
158}
159
164
165
166
167
174
175
176
177
178
183#if defined(BLAKE3_TESTING)
184 assert(0 < input_len);
186#endif
187
189 size_t input_position = 0;
190 size_t chunks_array_len = 0;
192 chunks_array[chunks_array_len] = &input[input_position];
194 chunks_array_len += 1;
195 }
196
200
201
202
203 if (input_len > input_position) {
204 uint64_t counter = chunk_counter + (uint64_t)chunks_array_len;
207 chunk_state.chunk_counter = counter;
209 input_len - input_position);
212 return chunks_array_len + 1;
213 } else {
214 return chunks_array_len;
215 }
216}
217
218
219
220
221
222
224 size_t num_chaining_values,
227#if defined(BLAKE3_TESTING)
228 assert(2 <= num_chaining_values);
230#endif
231
233 size_t parents_array_len = 0;
234 while (num_chaining_values - (2 * parents_array_len) >= 2) {
235 parents_array[parents_array_len] =
236 &child_chaining_values[2 * parents_array_len * BLAKE3_OUT_LEN];
237 parents_array_len += 1;
238 }
239
241 0,
242 false, flags | PARENT,
243 0,
244 0,
245 out);
246
247
248 if (num_chaining_values > 2 * parents_array_len) {
250 &child_chaining_values[2 * parents_array_len * BLAKE3_OUT_LEN],
252 return parents_array_len + 1;
253 } else {
254 return parents_array_len;
255 }
256}
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
278 uint8_t *out, bool use_tbb) {
279
280
281
282
285 out);
286 }
287
288
289
290
291
293 size_t right_input_len = input_len - left_input_len;
294 const uint8_t *right_input = &input[left_input_len];
295 uint64_t right_chunk_counter =
297
298
299
300
304
305
306
307
308 degree = 2;
309 }
311
312
313 size_t left_n = -1;
314 size_t right_n = -1;
315
316#if defined(BLAKE3_USE_TBB)
317 blake3_compress_subtree_wide_join_tbb(
318 key, flags, use_tbb,
319
320 input, left_input_len, chunk_counter, cv_array, &left_n,
321
322 right_input, right_input_len, right_chunk_counter, right_cvs, &right_n);
323#else
325 input, left_input_len, key, chunk_counter, flags, cv_array, use_tbb);
327 right_chunk_counter, flags, right_cvs,
328 use_tbb);
329#endif
330
331
332
333
334 if (left_n == 1) {
336 return 2;
337 }
338
339
340 size_t num_chaining_values = left_n + right_n;
342 out);
343}
344
345
346
347
348
349
350
351
352
353
354
359 bool use_tbb) {
360#if defined(BLAKE3_TESTING)
362#endif
363
366 chunk_counter, flags, cv_array, use_tbb);
368
369
370
371
372
373
374
375#if MAX_SIMD_DEGREE_OR_2 > 2
376
377
378
380 while (num_cvs > 2) {
381 num_cvs =
383 memcpy(cv_array, out_array, num_cvs * BLAKE3_OUT_LEN);
384 }
385#endif
387}
388
393 self->cv_stack_len = 0;
394}
395
397
404
406 size_t context_len) {
412 uint32_t context_key_words[8];
415}
416
420
421
422
423
424
425
426
427
428
429
430
432 size_t post_merge_stack_len = (size_t)popcnt(total_len);
433 while (self->cv_stack_len > post_merge_stack_len) {
435 &self->cv_stack[(self->cv_stack_len - 2) * BLAKE3_OUT_LEN];
438 self->cv_stack_len -= 1;
439 }
440}
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
477 memcpy(&self->cv_stack[self->cv_stack_len * BLAKE3_OUT_LEN], new_cv,
479 self->cv_stack_len += 1;
480}
481
483 size_t input_len, bool use_tbb) {
484
485
486
487
488 if (input_len == 0) {
489 return;
490 }
491
493
494
495
498 if (take > input_len) {
499 take = input_len;
500 }
502 input_bytes += take;
503 input_len -= take;
504
505
506 if (input_len > 0) {
510 hasher_push_cv(self, chunk_cv, self->chunk.chunk_counter);
511 chunk_state_reset(&self->chunk, self->key, self->chunk.chunk_counter + 1);
512 } else {
513 return;
514 }
515 }
516
517
518
519
520
521
522
523
524
525
526
527
528
529
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548 while ((((uint64_t)(subtree_len - 1)) & count_so_far) != 0) {
549 subtree_len /= 2;
550 }
551
552
556 chunk_state_init(&chunk_state, self->key, self->chunk.flags);
557 chunk_state.chunk_counter = self->chunk.chunk_counter;
563 } else {
564
565
568 self->chunk.chunk_counter,
569 self->chunk.flags, cv_pair, use_tbb);
570 hasher_push_cv(self, cv_pair, self->chunk.chunk_counter);
572 self->chunk.chunk_counter + (subtree_chunks / 2));
573 }
574 self->chunk.chunk_counter += subtree_chunks;
575 input_bytes += subtree_len;
576 input_len -= subtree_len;
577 }
578
579
580
581
582
583
584
585 if (input_len > 0) {
588 }
589}
590
592 size_t input_len) {
593 bool use_tbb = false;
595}
596
597#if defined(BLAKE3_USE_TBB)
598void blake3_hasher_update_tbb(blake3_hasher *self, const void *input,
599 size_t input_len) {
600 bool use_tbb = true;
602}
603#endif
604
606 size_t out_len) {
608#if LLVM_MEMORY_SANITIZER_BUILD
609
611#endif
612}
613
615 uint8_t *out, size_t out_len) {
616
617
618
619
620 if (out_len == 0) {
621 return;
622 }
623
624
625 if (self->cv_stack_len == 0) {
628 return;
629 }
630
631
632
633
634
635
636
638 size_t cvs_remaining;
640 cvs_remaining = self->cv_stack_len;
642 } else {
643
644 cvs_remaining = self->cv_stack_len - 2;
645 output = parent_output(&self->cv_stack[cvs_remaining * 32], self->key,
646 self->chunk.flags);
647 }
648 while (cvs_remaining > 0) {
649 cvs_remaining -= 1;
651 memcpy(parent_block, &self->cv_stack[cvs_remaining * 32], 32);
653 output = parent_output(parent_block, self->key, self->chunk.flags);
654 }
656}
657
660 self->cv_stack_len = 0;
661}
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
#define __msan_unpoison(p, size)
unify loop Fixup each natural loop to have a single exit block
INLINE void output_root_bytes(const output_t *self, uint64_t seek, uint8_t *out, size_t out_len)
Definition blake3.c:96
INLINE output_t make_output(const uint32_t input_cv[8], const uint8_t block[BLAKE3_BLOCK_LEN], uint8_t block_len, uint64_t counter, uint8_t flags)
Definition blake3.c:69
INLINE void chunk_state_update(blake3_chunk_state *self, const uint8_t *input, size_t input_len)
Definition blake3.c:125
INLINE size_t chunk_state_len(const blake3_chunk_state *self)
Definition blake3.c:36
void llvm_blake3_hasher_init(blake3_hasher *self)
Definition blake3.c:396
INLINE void hasher_init_base(blake3_hasher *self, const uint32_t key[8], uint8_t flags)
Definition blake3.c:389
void llvm_blake3_hasher_reset(blake3_hasher *self)
Definition blake3.c:658
INLINE void chunk_state_init(blake3_chunk_state *self, const uint32_t key[8], uint8_t flags)
Definition blake3.c:17
INLINE size_t chunk_state_fill_buf(blake3_chunk_state *self, const uint8_t *input, size_t input_len)
Definition blake3.c:41
INLINE size_t compress_chunks_parallel(const uint8_t *input, size_t input_len, const uint32_t key[8], uint64_t chunk_counter, uint8_t flags, uint8_t *out)
Definition blake3.c:179
INLINE void hasher_merge_cv_stack(blake3_hasher *self, uint64_t total_len)
Definition blake3.c:431
void llvm_blake3_hasher_update(blake3_hasher *self, const void *input, size_t input_len)
Definition blake3.c:591
void llvm_blake3_hasher_finalize(const blake3_hasher *self, uint8_t *out, size_t out_len)
Definition blake3.c:605
INLINE uint8_t chunk_state_maybe_start_flag(const blake3_chunk_state *self)
Definition blake3.c:53
INLINE void output_chaining_value(const output_t *self, uint8_t cv[32])
Definition blake3.c:88
INLINE output_t parent_output(const uint8_t block[BLAKE3_BLOCK_LEN], const uint32_t key[8], uint8_t flags)
Definition blake3.c:160
void llvm_blake3_hasher_finalize_seek(const blake3_hasher *self, uint64_t seek, uint8_t *out, size_t out_len)
Definition blake3.c:614
INLINE size_t compress_parents_parallel(const uint8_t *child_chaining_values, size_t num_chaining_values, const uint32_t key[8], uint8_t flags, uint8_t *out)
Definition blake3.c:223
const char * llvm_blake3_version(void)
Definition blake3.c:15
INLINE void chunk_state_reset(blake3_chunk_state *self, const uint32_t key[8], uint64_t chunk_counter)
Definition blake3.c:27
void llvm_blake3_hasher_init_keyed(blake3_hasher *self, const uint8_t key[BLAKE3_KEY_LEN])
Definition blake3.c:398
INLINE output_t chunk_state_output(const blake3_chunk_state *self)
Definition blake3.c:153
void llvm_blake3_hasher_init_derive_key_raw(blake3_hasher *self, const void *context, size_t context_len)
Definition blake3.c:405
void llvm_blake3_hasher_init_derive_key(blake3_hasher *self, const char *context)
Definition blake3.c:417
INLINE void compress_subtree_to_parent_node(const uint8_t *input, size_t input_len, const uint32_t key[8], uint64_t chunk_counter, uint8_t flags, uint8_t out[2 *BLAKE3_OUT_LEN], bool use_tbb)
Definition blake3.c:356
INLINE void hasher_push_cv(blake3_hasher *self, uint8_t new_cv[BLAKE3_OUT_LEN], uint64_t chunk_counter)
Definition blake3.c:474
INLINE size_t left_subtree_len(size_t input_len)
Definition blake3.c:168
INLINE void blake3_hasher_update_base(blake3_hasher *self, const void *input, size_t input_len, bool use_tbb)
Definition blake3.c:482
INLINE unsigned int popcnt(uint64_t x)
static const uint32_t IV[8]
INLINE void load_key_words(const uint8_t key[BLAKE3_KEY_LEN], uint32_t key_words[8])
#define MAX_SIMD_DEGREE_OR_2
INLINE void store_cv_words(uint8_t bytes_out[32], uint32_t cv_words[8])
INLINE uint64_t round_down_to_power_of_2(uint64_t x)
#define blake3_compress_xof
#define blake3_simd_degree
#define blake3_compress_in_place
#define BLAKE3_VERSION_STRING
#define blake3_chunk_state
#define blake3_compress_subtree_wide
uint8_t block_len
Definition blake3.c:65
uint8_t block[BLAKE3_BLOCK_LEN]
Definition blake3.c:64
uint64_t counter
Definition blake3.c:63
uint8_t flags
Definition blake3.c:66
uint32_t input_cv[8]
Definition blake3.c:62