Lines Matching +full:- +full:8 +full:g
2 // Accelerated CRC-T10DIF using ARM NEON and Crypto Extensions instructions
14 // Implement fast CRC-T10DIF computation with SSE and PCLMULQDQ instructions
62 // /white-papers/fast-crc-computation-generic-polynomials-pclmulqdq-paper.pdf
75 .arch armv8-a
76 .fpu crypto-neon-fp-armv8
118 vld1.64 {q11-q12}, [buf]!
125 CPU_LE( vrev64.8 q11, q11 )
126 CPU_LE( vrev64.8 q12, q12 )
130 veor.8 \reg1, \reg1, q8
131 veor.8 \reg2, \reg2, q9
132 veor.8 \reg1, \reg1, q11
133 veor.8 \reg2, \reg2, q12
143 veor.8 \dst_reg, \dst_reg, q8
144 veor.8 \dst_reg, \dst_reg, \src_reg
167 vld1.64 {q0-q1}, [buf]!
168 vld1.64 {q2-q3}, [buf]!
169 vld1.64 {q4-q5}, [buf]!
170 vld1.64 {q6-q7}, [buf]!
171 CPU_LE( vrev64.8 q0, q0 )
172 CPU_LE( vrev64.8 q1, q1 )
173 CPU_LE( vrev64.8 q2, q2 )
174 CPU_LE( vrev64.8 q3, q3 )
175 CPU_LE( vrev64.8 q4, q4 )
176 CPU_LE( vrev64.8 q5, q5 )
177 CPU_LE( vrev64.8 q6, q6 )
178 CPU_LE( vrev64.8 q7, q7 )
200 // While >= 128 data bytes remain (not counting q0-q7), fold the 128
201 // bytes q0-q7 into them, storing the result back into q0-q7.
210 // Now fold the 112 bytes in q0-q6 into the 16 bytes in q7.
228 adds len, len, #(128-16)
236 veor.8 q7, q7, q8
238 CPU_LE( vrev64.8 q0, q0 )
240 veor.8 q7, q7, q0
261 CPU_LE( vrev64.8 q0, q0 )
264 // q1 = high order part of second chunk: q7 left-shifted by 'len' bytes.
267 vld1.8 {q2}, [r3]
268 vtbl.8 q1l, {q7l-q7h}, q2l
269 vtbl.8 q1h, {q7l-q7h}, q2h
271 // q3 = first chunk: q7 right-shifted by '16-len' bytes.
273 veor.8 q2, q2, q3
274 vtbl.8 q3l, {q7l-q7h}, q2l
275 vtbl.8 q3h, {q7l-q7h}, q2h
277 // Convert to 8-bit masks: 'len' 0x00 bytes, then '16-len' 0xff bytes.
280 // q2 = second chunk: 'len' bytes from q0 (low-order bytes),
281 // then '16-len' bytes from q1 (high-order bytes).
282 vbsl.8 q2, q1, q0
287 veor.8 q7, q7, q0
288 veor.8 q7, q7, q2
291 // Reduce the 128-bit value M(x), stored in q7, to the final 16-bit CRC.
293 // Load 'x^48 * (x^48 mod G(x))' and 'x^48 * (x^80 mod G(x))'.
297 // x^64. This produces a 128-bit value congruent to x^64 * M(x) and
299 vmull.p64 q0, q7h, FOLD_CONST_H // high bits * x^48 * (x^80 mod G(x))
300 veor.8 q0h, q0h, q7l // + low bits * x^64
302 // Fold the high 32 bits into the low 96 bits. This produces a 96-bit
307 vmull.p64 q1, q1l, FOLD_CONST_L // high 32 bits * x^48 * (x^48 mod G(x))
308 veor.8 q0, q0, q1 // + low bits
310 // Load G(x) and floor(x^48 / G(x)).
314 vmull.p64 q1, q0h, FOLD_CONST_H // high 32 bits * floor(x^48 / G(x))
316 vmull.p64 q1, q1l, FOLD_CONST_L // *= G(x)
318 veor.8 q0l, q0l, q1l // + low 16 nonzero bits
319 // Final CRC value (x^16 * M(x)) mod G(x) is in low 16 bits of q0.
331 CPU_LE( vrev64.8 q7, q7 )
337 veor.8 q7h, q7h, q0h
339 // Load the fold-across-16-bytes constants.
354 // G(x) = x^16 + x^15 + x^11 + x^9 + x^8 + x^7 + x^5 + x^4 + x^2 + x^1 + x^0
356 .quad 0x0000000000006123 // x^(8*128) mod G(x)
357 .quad 0x0000000000002295 // x^(8*128+64) mod G(x)
359 .quad 0x0000000000001069 // x^(4*128) mod G(x)
360 .quad 0x000000000000dd31 // x^(4*128+64) mod G(x)
362 .quad 0x000000000000857d // x^(2*128) mod G(x)
363 .quad 0x0000000000007acc // x^(2*128+64) mod G(x)
365 .quad 0x000000000000a010 // x^(1*128) mod G(x)
366 .quad 0x0000000000001faa // x^(1*128+64) mod G(x)
368 .quad 0x1368000000000000 // x^48 * (x^48 mod G(x))
369 .quad 0x2d56000000000000 // x^48 * (x^80 mod G(x))
371 .quad 0x0000000000018bb7 // G(x)
372 .quad 0x00000001f65a57f8 // floor(x^48 / G(x))
374 // For 1 <= len <= 15, the 16-byte vector beginning at &byteshift_table[16 -
376 // ..., 0x80} XOR the index vector to shift right by '16 - len' bytes.