Debian Codegraph @

avo/avx2/hashP.go

raw
1 package main
2
3 import (
4 . "github.com/mmcloughlin/avo/build"
5 . "github.com/mmcloughlin/avo/operand"
6 . "github.com/mmcloughlin/avo/reg"
7 . "github.com/zeebo/blake3/avo"
8 )
9
10 func HashP(c Ctx) {
11 TEXT("HashP", NOSPLIT, `func(
12 left *[32]uint32,
13 right *[32]uint32,
14 flags uint8,
15 key *[8]uint32,
16 out *[32]uint32,
17 n int,
18 )`)
19
20 var (
21 left = Mem{Base: Load(Param("left"), GP64())}
22 right = Mem{Base: Load(Param("right"), GP64())}
23 flags = Load(Param("flags"), GP32()).(GPVirtual)
24 key = Mem{Base: Load(Param("key"), GP64())}
25 out = Mem{Base: Load(Param("out"), GP64())}
26 )
27
28 stash := GP64()
29
30 {
31 Comment("Allocate local space and align it")
32 local := AllocLocal(roundSize + 32)
33 LEAQ(local.Offset(31), stash)
34 // TODO: avo improvement
35 tmp := GP64()
36 MOVQ(U64(31), tmp)
37 NOTQ(tmp)
38 ANDQ(tmp, stash)
39 }
40
41 alloc := NewAlloc(Mem{Base: stash})
42 defer alloc.Free()
43
44 flags_mem := AllocLocal(8)
45
46 var (
47 h_vecs []*Value
48 vs []*Value
49 iv []*Value
50 ctr_low *Value
51 ctr_hi *Value
52 blen_vec *Value
53 flags_vec *Value
54 )
55
56 {
57 Comment("Set up flags value")
58 MOVL(flags, flags_mem)
59 }
60
61 h_vecs = alloc.ValuesWith(8, key)
62 iv = alloc.ValuesWith(4, c.IV)
63 ctr_low = alloc.ValueFrom(c.Zero)
64 ctr_hi = alloc.ValueFrom(c.Zero)
65 blen_vec = alloc.ValueFrom(c.BlockLen)
66 flags_vec = alloc.ValueWith(flags_mem)
67
68 {
69 Comment("Perform the rounds")
70
71 vs = []*Value{
72 h_vecs[0], h_vecs[1], h_vecs[2], h_vecs[3],
73 h_vecs[4], h_vecs[5], h_vecs[6], h_vecs[7],
74 iv[0], iv[1], iv[2], iv[3],
75 ctr_low, ctr_hi, blen_vec, flags_vec,
76 }
77
78 for r := 0; r < 7; r++ {
79 Commentf("Round %d", r+1)
80 roundP(c, alloc, vs, r, left, right)
81 }
82 }
83
84 {
85 Comment("Finalize")
86 finalizeRounds(alloc, vs, h_vecs, nil)
87 }
88
89 {
90 Comment("Store result into out")
91 for i, v := range h_vecs {
92 VMOVDQU(v.Consume(), out.Offset(32*i))
93 }
94 }
95
96 VZEROUPPER()
97 RET()
98 }
99
100 func roundP(c Ctx, alloc *Alloc, vs []*Value, r int, left, right Mem) {
101 round(c, alloc, vs, r, func(n int) Mem {
102 if n < 8 {
103 return left.Offset(n * 32)
104 } else {
105 return right.Offset((n - 8) * 32)
106 }
107 })
108 }