Debian Codegraph @

avo/sse41/compress.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 )
8
9 func main() {
10 ivMem := GLOBL("iv", RODATA|NOPTR)
11 for n, v := range []U32{
12 0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A,
13 0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19,
14 } {
15 DATA(4*n, v)
16 }
17
18 rot16Mem := GLOBL("rot16_shuf", RODATA|NOPTR)
19 for n, v := range []U8{
20 0x02, 0x03, 0x00, 0x01, 0x06, 0x07, 0x04, 0x05,
21 0x0A, 0x0B, 0x08, 0x09, 0x0E, 0x0F, 0x0C, 0x0D,
22 0x12, 0x13, 0x10, 0x11, 0x16, 0x17, 0x14, 0x15,
23 0x1A, 0x1B, 0x18, 0x19, 0x1E, 0x1F, 0x1C, 0x1D,
24 } {
25 DATA(n, v)
26 }
27
28 rot8Mem := GLOBL("rot8_shuf", RODATA|NOPTR)
29 for n, v := range []U8{
30 0x01, 0x02, 0x03, 0x00, 0x05, 0x06, 0x07, 0x04,
31 0x09, 0x0A, 0x0B, 0x08, 0x0D, 0x0E, 0x0F, 0x0C,
32 0x11, 0x12, 0x13, 0x10, 0x15, 0x16, 0x17, 0x14,
33 0x19, 0x1A, 0x1B, 0x18, 0x1D, 0x1E, 0x1F, 0x1C,
34 } {
35 DATA(n, v)
36 }
37
38 TEXT("Compress", NOSPLIT, `func(
39 chain *[8]uint32,
40 block *[16]uint32,
41 counter uint64,
42 blen uint32,
43 flags uint32,
44 out *[16]uint32,
45 )`)
46
47 var (
48 chain = Mem{Base: Load(Param("chain"), GP64())}
49 block = Mem{Base: Load(Param("block"), GP64())}
50 counter = Load(Param("counter"), GP64()).(GPVirtual)
51 blen = Load(Param("blen"), GP32()).(GPVirtual)
52 flags = Load(Param("flags"), GP32()).(GPVirtual)
53 out = Mem{Base: Load(Param("out"), GP64())}
54 )
55
56 rows := []VecVirtual{XMM(), XMM(), XMM(), XMM()}
57
58 MOVUPS(chain.Offset(0*16), rows[0])
59 MOVUPS(chain.Offset(1*16), rows[1])
60 MOVUPS(ivMem, rows[2])
61
62 PINSRD(U8(0), counter.As32(), rows[3])
63 SHRQ(U8(32), counter)
64 PINSRD(U8(1), counter.As32(), rows[3])
65 PINSRD(U8(2), blen, rows[3])
66 PINSRD(U8(3), flags, rows[3])
67
68 ms := []VecVirtual{XMM(), XMM(), XMM(), XMM()}
69
70 MOVUPS(block.Offset(0*16), ms[0])
71 MOVUPS(block.Offset(1*16), ms[1])
72 MOVUPS(block.Offset(2*16), ms[2])
73 MOVUPS(block.Offset(3*16), ms[3])
74
75 rot16, rot8 := XMM(), XMM()
76 MOVUPS(rot16Mem, rot16)
77 MOVUPS(rot8Mem, rot8)
78
79 {
80 Comment("round 1")
81
82 t0 := XMM()
83 MOVAPS(ms[0], t0) // 3 2 1 0
84 SHUFPS(pack(2, 0, 2, 0), ms[1], t0) // 6 4 2 0
85 g(rows, t0, rot16, 12) // 6 4 2 0
86
87 t1 := XMM()
88 MOVAPS(ms[0], t1) // 3 2 1 0
89 SHUFPS(pack(3, 1, 3, 1), ms[1], t1) // 7 5 3 1
90 g(rows, t1, rot8, 7) // 7 5 3 1
91
92 diagonalize(rows)
93
94 t2 := XMM()
95 MOVAPS(ms[2], t2) // b a 9 8
96 SHUFPS(pack(2, 0, 2, 0), ms[3], t2) // e c a 8
97 SHUFPS(pack(2, 1, 0, 3), t2, t2) // c a 8 e
98 g(rows, t2, rot16, 12) // c a 8 e
99
100 t3 := XMM()
101 MOVAPS(ms[2], t3) // b a 9 8
102 SHUFPS(pack(3, 1, 3, 1), ms[3], t3) // f d b 9
103 SHUFPS(pack(2, 1, 0, 3), t3, t3) // d b 9 f
104 g(rows, t3, rot8, 7) // d b 9 f
105
106 undiagonalize(rows)
107
108 ms[0] = t0
109 ms[1] = t1
110 ms[2] = t2
111 ms[3] = t3
112 }
113
114 for i := 1; i < 7; i++ {
115 tt := XMM()
116
117 Commentf("round %d", i+1)
118
119 t0 := XMM()
120 MOVAPS(ms[0], t0)
121 SHUFPS(pack(3, 1, 1, 2), ms[1], t0)
122 SHUFPS(pack(0, 3, 2, 1), t0, t0)
123 g(rows, t0, rot16, 12)
124
125 t1 := XMM()
126 MOVAPS(ms[2], t1)
127 SHUFPS(pack(3, 3, 2, 2), ms[3], t1)
128 PSHUFD(pack(0, 0, 3, 3), ms[0], tt)
129 PBLENDW(U8(0b00110011), tt, t1)
130 g(rows, t1, rot8, 7)
131
132 diagonalize(rows)
133
134 t2 := XMM()
135 MOVAPS(ms[3], t2)
136 PUNPCKLLQ(ms[1], t2)
137 PBLENDW(U8(0b11000000), ms[2], t2)
138 SHUFPS(pack(2, 3, 1, 0), t2, t2)
139 g(rows, t2, rot16, 12)
140
141 t3 := XMM()
142 MOVAPS(ms[1], tt)
143 PUNPCKHLQ(ms[3], tt)
144 MOVAPS(ms[2], t3)
145 PUNPCKLLQ(tt, t3)
146 SHUFPS(pack(0, 1, 3, 2), t3, t3)
147 g(rows, t3, rot8, 7)
148
149 undiagonalize(rows)
150
151 ms[0] = t0
152 ms[1] = t1
153 ms[2] = t2
154 ms[3] = t3
155 }
156
157 Comment("finalize")
158
159 PXOR(rows[2], rows[0])
160 PXOR(rows[3], rows[1])
161
162 tmp := XMM()
163 MOVUPS(chain.Offset(0*16), tmp)
164 PXOR(tmp, rows[2])
165 MOVUPS(chain.Offset(1*16), tmp)
166 PXOR(tmp, rows[3])
167
168 MOVUPS(rows[0], out.Offset(0*16))
169 MOVUPS(rows[1], out.Offset(1*16))
170 MOVUPS(rows[2], out.Offset(2*16))
171 MOVUPS(rows[3], out.Offset(3*16))
172
173 RET()
174
175 Generate()
176 }
177
178 func g(rows []VecVirtual, m VecVirtual, tab VecVirtual, n int) {
179 PADDD(m, rows[0])
180 PADDD(rows[1], rows[0])
181 PXOR(rows[0], rows[3])
182 PSHUFB(tab, rows[3])
183 PADDD(rows[3], rows[2])
184 PXOR(rows[2], rows[1])
185
186 tmp := XMM()
187 MOVAPS(rows[1], tmp)
188 PSRLL(U8(n), rows[1])
189 PSLLL(U8(32-n), tmp)
190 POR(tmp, rows[1])
191 }
192
193 func pack(a, b, c, d int) U8 {
194 return U8(a<<6 | b<<4 | c<<2 | d)
195 }
196
197 func diagonalize(rows []VecVirtual) {
198 PSHUFD(pack(2, 1, 0, 3), rows[0], rows[0])
199 PSHUFD(pack(1, 0, 3, 2), rows[3], rows[3])
200 PSHUFD(pack(0, 3, 2, 1), rows[2], rows[2])
201 }
202
203 func undiagonalize(rows []VecVirtual) {
204 PSHUFD(pack(0, 3, 2, 1), rows[0], rows[0])
205 PSHUFD(pack(1, 0, 3, 2), rows[3], rows[3])
206 PSHUFD(pack(2, 1, 0, 3), rows[2], rows[2])
207 }