Add AVX2/vpgather bulk implementation of Twofish
[libgcrypt.git] / cipher / twofish-avx2-amd64.S
1 /* twofish-avx2-amd64.S  -  AMD64/AVX2 assembly implementation of Twofish cipher
2  *
3  * Copyright (C) 2013-2017 Jussi Kivilinna <jussi.kivilinna@iki.fi>
4  *
5  * This file is part of Libgcrypt.
6  *
7  * Libgcrypt is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU Lesser General Public License as
9  * published by the Free Software Foundation; either version 2.1 of
10  * the License, or (at your option) any later version.
11  *
12  * Libgcrypt is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #ifdef __x86_64
22 #include <config.h>
23 #if (defined(HAVE_COMPATIBLE_GCC_AMD64_PLATFORM_AS) || \
24     defined(HAVE_COMPATIBLE_GCC_WIN64_PLATFORM_AS)) && defined(USE_TWOFISH) && \
25     defined(ENABLE_AVX2_SUPPORT)
26
27 #ifdef HAVE_COMPATIBLE_GCC_AMD64_PLATFORM_AS
28 # define ELF(...) __VA_ARGS__
29 #else
30 # define ELF(...) /*_*/
31 #endif
32
33 #ifdef __PIC__
34 #  define RIP (%rip)
35 #else
36 #  define RIP
37 #endif
38
39 .text
40
41 /* structure of TWOFISH_context: */
42 #define s0      0
43 #define s1      ((s0) + 4 * 256)
44 #define s2      ((s1) + 4 * 256)
45 #define s3      ((s2) + 4 * 256)
46 #define w       ((s3) + 4 * 256)
47 #define k       ((w) + 4 * 8)
48
49 /* register macros */
50 #define CTX     %rdi
51
52 #define RROUND  %rbp
53 #define RROUNDd %ebp
54 #define RS0     CTX
55 #define RS1     %r8
56 #define RS2     %r9
57 #define RS3     %r10
58 #define RK      %r11
59 #define RW      %rax
60
61 #define RA0     %ymm8
62 #define RB0     %ymm9
63 #define RC0     %ymm10
64 #define RD0     %ymm11
65 #define RA1     %ymm12
66 #define RB1     %ymm13
67 #define RC1     %ymm14
68 #define RD1     %ymm15
69
70 /* temp regs */
71 #define RX0     %ymm0
72 #define RY0     %ymm1
73 #define RX1     %ymm2
74 #define RY1     %ymm3
75 #define RT0     %ymm4
76 #define RIDX    %ymm5
77
78 #define RX0x    %xmm0
79 #define RY0x    %xmm1
80 #define RX1x    %xmm2
81 #define RY1x    %xmm3
82 #define RT0x    %xmm4
83 #define RIDXx   %xmm5
84
85 #define RTMP0   RX0
86 #define RTMP0x  RX0x
87 #define RTMP1   RX1
88 #define RTMP1x  RX1x
89 #define RTMP2   RY0
90 #define RTMP2x  RY0x
91 #define RTMP3   RY1
92 #define RTMP3x  RY1x
93 #define RTMP4   RIDX
94 #define RTMP4x  RIDXx
95
96 /* vpgatherdd mask and '-1' */
97 #define RNOT    %ymm6
98 #define RNOTx   %xmm6
99
100 /* byte mask, (-1 >> 24) */
101 #define RBYTE   %ymm7
102
103 /**********************************************************************
104   16-way AVX2 twofish
105  **********************************************************************/
106 #define init_round_constants() \
107         vpcmpeqd RNOT, RNOT, RNOT; \
108         leaq k(CTX), RK; \
109         leaq w(CTX), RW; \
110         vpsrld $24, RNOT, RBYTE; \
111         leaq s1(CTX), RS1; \
112         leaq s2(CTX), RS2; \
113         leaq s3(CTX), RS3; \
114
115 #define g16(ab, rs0, rs1, rs2, rs3, xy) \
116         vpand RBYTE, ab ## 0, RIDX; \
117         vpgatherdd RNOT, (rs0, RIDX, 4), xy ## 0; \
118         vpcmpeqd RNOT, RNOT, RNOT; \
119                 \
120                 vpand RBYTE, ab ## 1, RIDX; \
121                 vpgatherdd RNOT, (rs0, RIDX, 4), xy ## 1; \
122                 vpcmpeqd RNOT, RNOT, RNOT; \
123         \
124         vpsrld $8, ab ## 0, RIDX; \
125         vpand RBYTE, RIDX, RIDX; \
126         vpgatherdd RNOT, (rs1, RIDX, 4), RT0; \
127         vpcmpeqd RNOT, RNOT, RNOT; \
128         vpxor RT0, xy ## 0, xy ## 0; \
129                 \
130                 vpsrld $8, ab ## 1, RIDX; \
131                 vpand RBYTE, RIDX, RIDX; \
132                 vpgatherdd RNOT, (rs1, RIDX, 4), RT0; \
133                 vpcmpeqd RNOT, RNOT, RNOT; \
134                 vpxor RT0, xy ## 1, xy ## 1; \
135         \
136         vpsrld $16, ab ## 0, RIDX; \
137         vpand RBYTE, RIDX, RIDX; \
138         vpgatherdd RNOT, (rs2, RIDX, 4), RT0; \
139         vpcmpeqd RNOT, RNOT, RNOT; \
140         vpxor RT0, xy ## 0, xy ## 0; \
141                 \
142                 vpsrld $16, ab ## 1, RIDX; \
143                 vpand RBYTE, RIDX, RIDX; \
144                 vpgatherdd RNOT, (rs2, RIDX, 4), RT0; \
145                 vpcmpeqd RNOT, RNOT, RNOT; \
146                 vpxor RT0, xy ## 1, xy ## 1; \
147         \
148         vpsrld $24, ab ## 0, RIDX; \
149         vpgatherdd RNOT, (rs3, RIDX, 4), RT0; \
150         vpcmpeqd RNOT, RNOT, RNOT; \
151         vpxor RT0, xy ## 0, xy ## 0; \
152                 \
153                 vpsrld $24, ab ## 1, RIDX; \
154                 vpgatherdd RNOT, (rs3, RIDX, 4), RT0; \
155                 vpcmpeqd RNOT, RNOT, RNOT; \
156                 vpxor RT0, xy ## 1, xy ## 1;
157
158 #define g1_16(a, x) \
159         g16(a, RS0, RS1, RS2, RS3, x);
160
161 #define g2_16(b, y) \
162         g16(b, RS1, RS2, RS3, RS0, y);
163
164 #define encrypt_round_end16(a, b, c, d, nk, r) \
165         vpaddd RY0, RX0, RX0; \
166         vpaddd RX0, RY0, RY0; \
167         vpbroadcastd ((nk)+((r)*8))(RK), RT0; \
168         vpaddd RT0, RX0, RX0; \
169         vpbroadcastd 4+((nk)+((r)*8))(RK), RT0; \
170         vpaddd RT0, RY0, RY0; \
171         \
172         vpxor RY0, d ## 0, d ## 0; \
173         \
174         vpxor RX0, c ## 0, c ## 0; \
175         vpsrld $1, c ## 0, RT0; \
176         vpslld $31, c ## 0, c ## 0; \
177         vpor RT0, c ## 0, c ## 0; \
178         \
179                 vpaddd RY1, RX1, RX1; \
180                 vpaddd RX1, RY1, RY1; \
181                 vpbroadcastd ((nk)+((r)*8))(RK), RT0; \
182                 vpaddd RT0, RX1, RX1; \
183                 vpbroadcastd 4+((nk)+((r)*8))(RK), RT0; \
184                 vpaddd RT0, RY1, RY1; \
185                 \
186                 vpxor RY1, d ## 1, d ## 1; \
187                 \
188                 vpxor RX1, c ## 1, c ## 1; \
189                 vpsrld $1, c ## 1, RT0; \
190                 vpslld $31, c ## 1, c ## 1; \
191                 vpor RT0, c ## 1, c ## 1; \
192
193 #define encrypt_round16(a, b, c, d, nk, r) \
194         g2_16(b, RY); \
195         \
196         vpslld $1, b ## 0, RT0; \
197         vpsrld $31, b ## 0, b ## 0; \
198         vpor RT0, b ## 0, b ## 0; \
199         \
200                 vpslld $1, b ## 1, RT0; \
201                 vpsrld $31, b ## 1, b ## 1; \
202                 vpor RT0, b ## 1, b ## 1; \
203         \
204         g1_16(a, RX); \
205         \
206         encrypt_round_end16(a, b, c, d, nk, r);
207
208 #define encrypt_round_first16(a, b, c, d, nk, r) \
209         vpslld $1, d ## 0, RT0; \
210         vpsrld $31, d ## 0, d ## 0; \
211         vpor RT0, d ## 0, d ## 0; \
212         \
213                 vpslld $1, d ## 1, RT0; \
214                 vpsrld $31, d ## 1, d ## 1; \
215                 vpor RT0, d ## 1, d ## 1; \
216         \
217         encrypt_round16(a, b, c, d, nk, r);
218
219 #define encrypt_round_last16(a, b, c, d, nk, r) \
220         g2_16(b, RY); \
221         \
222         g1_16(a, RX); \
223         \
224         encrypt_round_end16(a, b, c, d, nk, r);
225
226 #define decrypt_round_end16(a, b, c, d, nk, r) \
227         vpaddd RY0, RX0, RX0; \
228         vpaddd RX0, RY0, RY0; \
229         vpbroadcastd ((nk)+((r)*8))(RK), RT0; \
230         vpaddd RT0, RX0, RX0; \
231         vpbroadcastd 4+((nk)+((r)*8))(RK), RT0; \
232         vpaddd RT0, RY0, RY0; \
233         \
234         vpxor RX0, c ## 0, c ## 0; \
235         \
236         vpxor RY0, d ## 0, d ## 0; \
237         vpsrld $1, d ## 0, RT0; \
238         vpslld $31, d ## 0, d ## 0; \
239         vpor RT0, d ## 0, d ## 0; \
240         \
241                 vpaddd RY1, RX1, RX1; \
242                 vpaddd RX1, RY1, RY1; \
243                 vpbroadcastd ((nk)+((r)*8))(RK), RT0; \
244                 vpaddd RT0, RX1, RX1; \
245                 vpbroadcastd 4+((nk)+((r)*8))(RK), RT0; \
246                 vpaddd RT0, RY1, RY1; \
247                 \
248                 vpxor RX1, c ## 1, c ## 1; \
249                 \
250                 vpxor RY1, d ## 1, d ## 1; \
251                 vpsrld $1, d ## 1, RT0; \
252                 vpslld $31, d ## 1, d ## 1; \
253                 vpor RT0, d ## 1, d ## 1;
254
255 #define decrypt_round16(a, b, c, d, nk, r) \
256         g1_16(a, RX); \
257         \
258         vpslld $1, a ## 0, RT0; \
259         vpsrld $31, a ## 0, a ## 0; \
260         vpor RT0, a ## 0, a ## 0; \
261         \
262                 vpslld $1, a ## 1, RT0; \
263                 vpsrld $31, a ## 1, a ## 1; \
264                 vpor RT0, a ## 1, a ## 1; \
265         \
266         g2_16(b, RY); \
267         \
268         decrypt_round_end16(a, b, c, d, nk, r);
269
270 #define decrypt_round_first16(a, b, c, d, nk, r) \
271         vpslld $1, c ## 0, RT0; \
272         vpsrld $31, c ## 0, c ## 0; \
273         vpor RT0, c ## 0, c ## 0; \
274         \
275                 vpslld $1, c ## 1, RT0; \
276                 vpsrld $31, c ## 1, c ## 1; \
277                 vpor RT0, c ## 1, c ## 1; \
278         \
279         decrypt_round16(a, b, c, d, nk, r)
280
281 #define decrypt_round_last16(a, b, c, d, nk, r) \
282         g1_16(a, RX); \
283         \
284         g2_16(b, RY); \
285         \
286         decrypt_round_end16(a, b, c, d, nk, r);
287
288 #define encrypt_cycle16(r) \
289         encrypt_round16(RA, RB, RC, RD, 0, r); \
290         encrypt_round16(RC, RD, RA, RB, 8, r);
291
292 #define encrypt_cycle_first16(r) \
293         encrypt_round_first16(RA, RB, RC, RD, 0, r); \
294         encrypt_round16(RC, RD, RA, RB, 8, r);
295
296 #define encrypt_cycle_last16(r) \
297         encrypt_round16(RA, RB, RC, RD, 0, r); \
298         encrypt_round_last16(RC, RD, RA, RB, 8, r);
299
300 #define decrypt_cycle16(r) \
301         decrypt_round16(RC, RD, RA, RB, 8, r); \
302         decrypt_round16(RA, RB, RC, RD, 0, r);
303
304 #define decrypt_cycle_first16(r) \
305         decrypt_round_first16(RC, RD, RA, RB, 8, r); \
306         decrypt_round16(RA, RB, RC, RD, 0, r);
307
308 #define decrypt_cycle_last16(r) \
309         decrypt_round16(RC, RD, RA, RB, 8, r); \
310         decrypt_round_last16(RA, RB, RC, RD, 0, r);
311
312 #define transpose_4x4(x0,x1,x2,x3,t1,t2) \
313         vpunpckhdq x1, x0, t2; \
314         vpunpckldq x1, x0, x0; \
315         \
316         vpunpckldq x3, x2, t1; \
317         vpunpckhdq x3, x2, x2; \
318         \
319         vpunpckhqdq t1, x0, x1; \
320         vpunpcklqdq t1, x0, x0; \
321         \
322         vpunpckhqdq x2, t2, x3; \
323         vpunpcklqdq x2, t2, x2;
324
325 #define read_blocks8(offs,a,b,c,d) \
326         vmovdqu 16*offs(RIO), a; \
327         vmovdqu 16*offs+32(RIO), b; \
328         vmovdqu 16*offs+64(RIO), c; \
329         vmovdqu 16*offs+96(RIO), d; \
330         \
331         transpose_4x4(a, b, c, d, RX0, RY0);
332
333 #define write_blocks8(offs,a,b,c,d) \
334         transpose_4x4(a, b, c, d, RX0, RY0); \
335         \
336         vmovdqu a, 16*offs(RIO); \
337         vmovdqu b, 16*offs+32(RIO); \
338         vmovdqu c, 16*offs+64(RIO); \
339         vmovdqu d, 16*offs+96(RIO);
340
341 #define inpack_enc8(a,b,c,d) \
342         vpbroadcastd 4*0(RW), RT0; \
343         vpxor RT0, a, a; \
344         \
345         vpbroadcastd 4*1(RW), RT0; \
346         vpxor RT0, b, b; \
347         \
348         vpbroadcastd 4*2(RW), RT0; \
349         vpxor RT0, c, c; \
350         \
351         vpbroadcastd 4*3(RW), RT0; \
352         vpxor RT0, d, d;
353
354 #define outunpack_enc8(a,b,c,d) \
355         vpbroadcastd 4*4(RW), RX0; \
356         vpbroadcastd 4*5(RW), RY0; \
357         vpxor RX0, c, RX0; \
358         vpxor RY0, d, RY0; \
359         \
360         vpbroadcastd 4*6(RW), RT0; \
361         vpxor RT0, a, c; \
362         vpbroadcastd 4*7(RW), RT0; \
363         vpxor RT0, b, d; \
364         \
365         vmovdqa RX0, a; \
366         vmovdqa RY0, b;
367
368 #define inpack_dec8(a,b,c,d) \
369         vpbroadcastd 4*4(RW), RX0; \
370         vpbroadcastd 4*5(RW), RY0; \
371         vpxor RX0, a, RX0; \
372         vpxor RY0, b, RY0; \
373         \
374         vpbroadcastd 4*6(RW), RT0; \
375         vpxor RT0, c, a; \
376         vpbroadcastd 4*7(RW), RT0; \
377         vpxor RT0, d, b; \
378         \
379         vmovdqa RX0, c; \
380         vmovdqa RY0, d;
381
382 #define outunpack_dec8(a,b,c,d) \
383         vpbroadcastd 4*0(RW), RT0; \
384         vpxor RT0, a, a; \
385         \
386         vpbroadcastd 4*1(RW), RT0; \
387         vpxor RT0, b, b; \
388         \
389         vpbroadcastd 4*2(RW), RT0; \
390         vpxor RT0, c, c; \
391         \
392         vpbroadcastd 4*3(RW), RT0; \
393         vpxor RT0, d, d;
394
395 #define transpose4x4_16(a,b,c,d) \
396         transpose_4x4(a ## 0, b ## 0, c ## 0, d ## 0, RX0, RY0); \
397         transpose_4x4(a ## 1, b ## 1, c ## 1, d ## 1, RX0, RY0);
398
399 #define inpack_enc16(a,b,c,d) \
400         inpack_enc8(a ## 0, b ## 0, c ## 0, d ## 0); \
401         inpack_enc8(a ## 1, b ## 1, c ## 1, d ## 1);
402
403 #define outunpack_enc16(a,b,c,d) \
404         outunpack_enc8(a ## 0, b ## 0, c ## 0, d ## 0); \
405         outunpack_enc8(a ## 1, b ## 1, c ## 1, d ## 1);
406
407 #define inpack_dec16(a,b,c,d) \
408         inpack_dec8(a ## 0, b ## 0, c ## 0, d ## 0); \
409         inpack_dec8(a ## 1, b ## 1, c ## 1, d ## 1);
410
411 #define outunpack_dec16(a,b,c,d) \
412         outunpack_dec8(a ## 0, b ## 0, c ## 0, d ## 0); \
413         outunpack_dec8(a ## 1, b ## 1, c ## 1, d ## 1);
414
415 .align 8
416 ELF(.type __twofish_enc_blk16,@function;)
417 __twofish_enc_blk16:
418         /* input:
419          *      %rdi: ctx, CTX
420          *      RA0, RB0, RC0, RD0, RA1, RB1, RC1, RD1: sixteen parallel
421          *                                              plaintext blocks
422          * output:
423          *      RA0, RB0, RC0, RD0, RA1, RB1, RC1, RD1: sixteen parallel
424          *                                              ciphertext blocks
425          */
426         init_round_constants();
427
428         transpose4x4_16(RA, RB, RC, RD);
429         inpack_enc16(RA, RB, RC, RD);
430
431         encrypt_cycle_first16(0);
432         encrypt_cycle16(2);
433         encrypt_cycle16(4);
434         encrypt_cycle16(6);
435         encrypt_cycle16(8);
436         encrypt_cycle16(10);
437         encrypt_cycle16(12);
438         encrypt_cycle_last16(14);
439
440         outunpack_enc16(RA, RB, RC, RD);
441         transpose4x4_16(RA, RB, RC, RD);
442
443         ret;
444 ELF(.size __twofish_enc_blk16,.-__twofish_enc_blk16;)
445
446 .align 8
447 ELF(.type __twofish_dec_blk16,@function;)
448 __twofish_dec_blk16:
449         /* input:
450          *      %rdi: ctx, CTX
451          *      RA0, RB0, RC0, RD0, RA1, RB1, RC1, RD1: sixteen parallel
452          *                                              plaintext blocks
453          * output:
454          *      RA0, RB0, RC0, RD0, RA1, RB1, RC1, RD1: sixteen parallel
455          *                                              ciphertext blocks
456          */
457         init_round_constants();
458
459         transpose4x4_16(RA, RB, RC, RD);
460         inpack_dec16(RA, RB, RC, RD);
461
462         decrypt_cycle_first16(14);
463         decrypt_cycle16(12);
464         decrypt_cycle16(10);
465         decrypt_cycle16(8);
466         decrypt_cycle16(6);
467         decrypt_cycle16(4);
468         decrypt_cycle16(2);
469         decrypt_cycle_last16(0);
470
471         outunpack_dec16(RA, RB, RC, RD);
472         transpose4x4_16(RA, RB, RC, RD);
473
474         ret;
475 ELF(.size __twofish_dec_blk16,.-__twofish_dec_blk16;)
476
477 #define inc_le128(x, minus_one, tmp) \
478         vpcmpeqq minus_one, x, tmp; \
479         vpsubq minus_one, x, x; \
480         vpslldq $8, tmp, tmp; \
481         vpsubq tmp, x, x;
482
483 .align 8
484 .globl _gcry_twofish_avx2_ctr_enc
485 ELF(.type   _gcry_twofish_avx2_ctr_enc,@function;)
486 _gcry_twofish_avx2_ctr_enc:
487         /* input:
488          *      %rdi: ctx, CTX
489          *      %rsi: dst (16 blocks)
490          *      %rdx: src (16 blocks)
491          *      %rcx: iv (big endian, 128bit)
492          */
493
494         movq 8(%rcx), %rax;
495         bswapq %rax;
496
497         vzeroupper;
498
499         vbroadcasti128 .Lbswap128_mask RIP, RTMP3;
500         vpcmpeqd RNOT, RNOT, RNOT;
501         vpsrldq $8, RNOT, RNOT;   /* ab: -1:0 ; cd: -1:0 */
502         vpaddq RNOT, RNOT, RTMP2; /* ab: -2:0 ; cd: -2:0 */
503
504         /* load IV and byteswap */
505         vmovdqu (%rcx), RTMP4x;
506         vpshufb RTMP3x, RTMP4x, RTMP4x;
507         vmovdqa RTMP4x, RTMP0x;
508         inc_le128(RTMP4x, RNOTx, RTMP1x);
509         vinserti128 $1, RTMP4x, RTMP0, RTMP0;
510         vpshufb RTMP3, RTMP0, RA0; /* +1 ; +0 */
511
512         /* check need for handling 64-bit overflow and carry */
513         cmpq $(0xffffffffffffffff - 16), %rax;
514         ja .Lhandle_ctr_carry;
515
516         /* construct IVs */
517         vpsubq RTMP2, RTMP0, RTMP0; /* +3 ; +2 */
518         vpshufb RTMP3, RTMP0, RB0;
519         vpsubq RTMP2, RTMP0, RTMP0; /* +5 ; +4 */
520         vpshufb RTMP3, RTMP0, RC0;
521         vpsubq RTMP2, RTMP0, RTMP0; /* +7 ; +6 */
522         vpshufb RTMP3, RTMP0, RD0;
523         vpsubq RTMP2, RTMP0, RTMP0; /* +9 ; +8 */
524         vpshufb RTMP3, RTMP0, RA1;
525         vpsubq RTMP2, RTMP0, RTMP0; /* +11 ; +10 */
526         vpshufb RTMP3, RTMP0, RB1;
527         vpsubq RTMP2, RTMP0, RTMP0; /* +13 ; +12 */
528         vpshufb RTMP3, RTMP0, RC1;
529         vpsubq RTMP2, RTMP0, RTMP0; /* +15 ; +14 */
530         vpshufb RTMP3, RTMP0, RD1;
531         vpsubq RTMP2, RTMP0, RTMP0; /* +16 */
532         vpshufb RTMP3x, RTMP0x, RTMP0x;
533
534         jmp .Lctr_carry_done;
535
536 .Lhandle_ctr_carry:
537         /* construct IVs */
538         inc_le128(RTMP0, RNOT, RTMP1);
539         inc_le128(RTMP0, RNOT, RTMP1);
540         vpshufb RTMP3, RTMP0, RB0; /* +3 ; +2 */
541         inc_le128(RTMP0, RNOT, RTMP1);
542         inc_le128(RTMP0, RNOT, RTMP1);
543         vpshufb RTMP3, RTMP0, RC0; /* +5 ; +4 */
544         inc_le128(RTMP0, RNOT, RTMP1);
545         inc_le128(RTMP0, RNOT, RTMP1);
546         vpshufb RTMP3, RTMP0, RD0; /* +7 ; +6 */
547         inc_le128(RTMP0, RNOT, RTMP1);
548         inc_le128(RTMP0, RNOT, RTMP1);
549         vpshufb RTMP3, RTMP0, RA1; /* +9 ; +8 */
550         inc_le128(RTMP0, RNOT, RTMP1);
551         inc_le128(RTMP0, RNOT, RTMP1);
552         vpshufb RTMP3, RTMP0, RB1; /* +11 ; +10 */
553         inc_le128(RTMP0, RNOT, RTMP1);
554         inc_le128(RTMP0, RNOT, RTMP1);
555         vpshufb RTMP3, RTMP0, RC1; /* +13 ; +12 */
556         inc_le128(RTMP0, RNOT, RTMP1);
557         inc_le128(RTMP0, RNOT, RTMP1);
558         vpshufb RTMP3, RTMP0, RD1; /* +15 ; +14 */
559         inc_le128(RTMP0, RNOT, RTMP1);
560         vextracti128 $1, RTMP0, RTMP0x;
561         vpshufb RTMP3x, RTMP0x, RTMP0x; /* +16 */
562
563 .align 4
564 .Lctr_carry_done:
565         /* store new IV */
566         vmovdqu RTMP0x, (%rcx);
567
568         call __twofish_enc_blk16;
569
570         vpxor (0 * 32)(%rdx), RA0, RA0;
571         vpxor (1 * 32)(%rdx), RB0, RB0;
572         vpxor (2 * 32)(%rdx), RC0, RC0;
573         vpxor (3 * 32)(%rdx), RD0, RD0;
574         vpxor (4 * 32)(%rdx), RA1, RA1;
575         vpxor (5 * 32)(%rdx), RB1, RB1;
576         vpxor (6 * 32)(%rdx), RC1, RC1;
577         vpxor (7 * 32)(%rdx), RD1, RD1;
578
579         vmovdqu RA0, (0 * 32)(%rsi);
580         vmovdqu RB0, (1 * 32)(%rsi);
581         vmovdqu RC0, (2 * 32)(%rsi);
582         vmovdqu RD0, (3 * 32)(%rsi);
583         vmovdqu RA1, (4 * 32)(%rsi);
584         vmovdqu RB1, (5 * 32)(%rsi);
585         vmovdqu RC1, (6 * 32)(%rsi);
586         vmovdqu RD1, (7 * 32)(%rsi);
587
588         vzeroall;
589
590         ret
591 ELF(.size _gcry_twofish_avx2_ctr_enc,.-_gcry_twofish_avx2_ctr_enc;)
592
593 .align 8
594 .globl _gcry_twofish_avx2_cbc_dec
595 ELF(.type   _gcry_twofish_avx2_cbc_dec,@function;)
596 _gcry_twofish_avx2_cbc_dec:
597         /* input:
598          *      %rdi: ctx, CTX
599          *      %rsi: dst (16 blocks)
600          *      %rdx: src (16 blocks)
601          *      %rcx: iv
602          */
603
604         vzeroupper;
605
606         vmovdqu (0 * 32)(%rdx), RA0;
607         vmovdqu (1 * 32)(%rdx), RB0;
608         vmovdqu (2 * 32)(%rdx), RC0;
609         vmovdqu (3 * 32)(%rdx), RD0;
610         vmovdqu (4 * 32)(%rdx), RA1;
611         vmovdqu (5 * 32)(%rdx), RB1;
612         vmovdqu (6 * 32)(%rdx), RC1;
613         vmovdqu (7 * 32)(%rdx), RD1;
614
615         call __twofish_dec_blk16;
616
617         vmovdqu (%rcx), RNOTx;
618         vinserti128 $1, (%rdx), RNOT, RNOT;
619         vpxor RNOT, RA0, RA0;
620         vpxor (0 * 32 + 16)(%rdx), RB0, RB0;
621         vpxor (1 * 32 + 16)(%rdx), RC0, RC0;
622         vpxor (2 * 32 + 16)(%rdx), RD0, RD0;
623         vpxor (3 * 32 + 16)(%rdx), RA1, RA1;
624         vpxor (4 * 32 + 16)(%rdx), RB1, RB1;
625         vpxor (5 * 32 + 16)(%rdx), RC1, RC1;
626         vpxor (6 * 32 + 16)(%rdx), RD1, RD1;
627         vmovdqu (7 * 32 + 16)(%rdx), RNOTx;
628         vmovdqu RNOTx, (%rcx); /* store new IV */
629
630         vmovdqu RA0, (0 * 32)(%rsi);
631         vmovdqu RB0, (1 * 32)(%rsi);
632         vmovdqu RC0, (2 * 32)(%rsi);
633         vmovdqu RD0, (3 * 32)(%rsi);
634         vmovdqu RA1, (4 * 32)(%rsi);
635         vmovdqu RB1, (5 * 32)(%rsi);
636         vmovdqu RC1, (6 * 32)(%rsi);
637         vmovdqu RD1, (7 * 32)(%rsi);
638
639         vzeroall;
640
641         ret
642 ELF(.size _gcry_twofish_avx2_cbc_dec,.-_gcry_twofish_avx2_cbc_dec;)
643
644 .align 8
645 .globl _gcry_twofish_avx2_cfb_dec
646 ELF(.type   _gcry_twofish_avx2_cfb_dec,@function;)
647 _gcry_twofish_avx2_cfb_dec:
648         /* input:
649          *      %rdi: ctx, CTX
650          *      %rsi: dst (16 blocks)
651          *      %rdx: src (16 blocks)
652          *      %rcx: iv
653          */
654
655         vzeroupper;
656
657         /* Load input */
658         vmovdqu (%rcx), RNOTx;
659         vinserti128 $1, (%rdx), RNOT, RA0;
660         vmovdqu (0 * 32 + 16)(%rdx), RB0;
661         vmovdqu (1 * 32 + 16)(%rdx), RC0;
662         vmovdqu (2 * 32 + 16)(%rdx), RD0;
663         vmovdqu (3 * 32 + 16)(%rdx), RA1;
664         vmovdqu (4 * 32 + 16)(%rdx), RB1;
665         vmovdqu (5 * 32 + 16)(%rdx), RC1;
666         vmovdqu (6 * 32 + 16)(%rdx), RD1;
667
668         /* Update IV */
669         vmovdqu (7 * 32 + 16)(%rdx), RNOTx;
670         vmovdqu RNOTx, (%rcx);
671
672         call __twofish_enc_blk16;
673
674         vpxor (0 * 32)(%rdx), RA0, RA0;
675         vpxor (1 * 32)(%rdx), RB0, RB0;
676         vpxor (2 * 32)(%rdx), RC0, RC0;
677         vpxor (3 * 32)(%rdx), RD0, RD0;
678         vpxor (4 * 32)(%rdx), RA1, RA1;
679         vpxor (5 * 32)(%rdx), RB1, RB1;
680         vpxor (6 * 32)(%rdx), RC1, RC1;
681         vpxor (7 * 32)(%rdx), RD1, RD1;
682
683         vmovdqu RA0, (0 * 32)(%rsi);
684         vmovdqu RB0, (1 * 32)(%rsi);
685         vmovdqu RC0, (2 * 32)(%rsi);
686         vmovdqu RD0, (3 * 32)(%rsi);
687         vmovdqu RA1, (4 * 32)(%rsi);
688         vmovdqu RB1, (5 * 32)(%rsi);
689         vmovdqu RC1, (6 * 32)(%rsi);
690         vmovdqu RD1, (7 * 32)(%rsi);
691
692         vzeroall;
693
694         ret
695 ELF(.size _gcry_twofish_avx2_cfb_dec,.-_gcry_twofish_avx2_cfb_dec;)
696
697 .align 8
698 .globl _gcry_twofish_avx2_ocb_enc
699 ELF(.type _gcry_twofish_avx2_ocb_enc,@function;)
700
701 _gcry_twofish_avx2_ocb_enc:
702         /* input:
703          *      %rdi: ctx, CTX
704          *      %rsi: dst (16 blocks)
705          *      %rdx: src (16 blocks)
706          *      %rcx: offset
707          *      %r8 : checksum
708          *      %r9 : L pointers (void *L[16])
709          */
710
711         vzeroupper;
712
713         subq $(4 * 8), %rsp;
714
715         movq %r10, (0 * 8)(%rsp);
716         movq %r11, (1 * 8)(%rsp);
717         movq %r12, (2 * 8)(%rsp);
718         movq %r13, (3 * 8)(%rsp);
719
720         vmovdqu (%rcx), RTMP0x;
721         vmovdqu (%r8), RTMP1x;
722
723         /* Offset_i = Offset_{i-1} xor L_{ntz(i)} */
724         /* Checksum_i = Checksum_{i-1} xor P_i  */
725         /* C_i = Offset_i xor ENCIPHER(K, P_i xor Offset_i)  */
726
727 #define OCB_INPUT(n, l0reg, l1reg, yreg) \
728           vmovdqu (n * 32)(%rdx), yreg; \
729           vpxor (l0reg), RTMP0x, RNOTx; \
730           vpxor (l1reg), RNOTx, RTMP0x; \
731           vinserti128 $1, RTMP0x, RNOT, RNOT; \
732           vpxor yreg, RTMP1, RTMP1; \
733           vpxor yreg, RNOT, yreg; \
734           vmovdqu RNOT, (n * 32)(%rsi);
735
736         movq (0 * 8)(%r9), %r10;
737         movq (1 * 8)(%r9), %r11;
738         movq (2 * 8)(%r9), %r12;
739         movq (3 * 8)(%r9), %r13;
740         OCB_INPUT(0, %r10, %r11, RA0);
741         OCB_INPUT(1, %r12, %r13, RB0);
742         movq (4 * 8)(%r9), %r10;
743         movq (5 * 8)(%r9), %r11;
744         movq (6 * 8)(%r9), %r12;
745         movq (7 * 8)(%r9), %r13;
746         OCB_INPUT(2, %r10, %r11, RC0);
747         OCB_INPUT(3, %r12, %r13, RD0);
748         movq (8 * 8)(%r9), %r10;
749         movq (9 * 8)(%r9), %r11;
750         movq (10 * 8)(%r9), %r12;
751         movq (11 * 8)(%r9), %r13;
752         OCB_INPUT(4, %r10, %r11, RA1);
753         OCB_INPUT(5, %r12, %r13, RB1);
754         movq (12 * 8)(%r9), %r10;
755         movq (13 * 8)(%r9), %r11;
756         movq (14 * 8)(%r9), %r12;
757         movq (15 * 8)(%r9), %r13;
758         OCB_INPUT(6, %r10, %r11, RC1);
759         OCB_INPUT(7, %r12, %r13, RD1);
760 #undef OCB_INPUT
761
762         vextracti128 $1, RTMP1, RNOTx;
763         vmovdqu RTMP0x, (%rcx);
764         vpxor RNOTx, RTMP1x, RTMP1x;
765         vmovdqu RTMP1x, (%r8);
766
767         movq (0 * 8)(%rsp), %r10;
768         movq (1 * 8)(%rsp), %r11;
769         movq (2 * 8)(%rsp), %r12;
770         movq (3 * 8)(%rsp), %r13;
771
772         call __twofish_enc_blk16;
773
774         addq $(4 * 8), %rsp;
775
776         vpxor (0 * 32)(%rsi), RA0, RA0;
777         vpxor (1 * 32)(%rsi), RB0, RB0;
778         vpxor (2 * 32)(%rsi), RC0, RC0;
779         vpxor (3 * 32)(%rsi), RD0, RD0;
780         vpxor (4 * 32)(%rsi), RA1, RA1;
781         vpxor (5 * 32)(%rsi), RB1, RB1;
782         vpxor (6 * 32)(%rsi), RC1, RC1;
783         vpxor (7 * 32)(%rsi), RD1, RD1;
784
785         vmovdqu RA0, (0 * 32)(%rsi);
786         vmovdqu RB0, (1 * 32)(%rsi);
787         vmovdqu RC0, (2 * 32)(%rsi);
788         vmovdqu RD0, (3 * 32)(%rsi);
789         vmovdqu RA1, (4 * 32)(%rsi);
790         vmovdqu RB1, (5 * 32)(%rsi);
791         vmovdqu RC1, (6 * 32)(%rsi);
792         vmovdqu RD1, (7 * 32)(%rsi);
793
794         vzeroall;
795
796         ret;
797 ELF(.size _gcry_twofish_avx2_ocb_enc,.-_gcry_twofish_avx2_ocb_enc;)
798
799 .align 8
800 .globl _gcry_twofish_avx2_ocb_dec
801 ELF(.type _gcry_twofish_avx2_ocb_dec,@function;)
802
803 _gcry_twofish_avx2_ocb_dec:
804         /* input:
805          *      %rdi: ctx, CTX
806          *      %rsi: dst (16 blocks)
807          *      %rdx: src (16 blocks)
808          *      %rcx: offset
809          *      %r8 : checksum
810          *      %r9 : L pointers (void *L[16])
811          */
812
813         vzeroupper;
814
815         subq $(4 * 8), %rsp;
816
817         movq %r10, (0 * 8)(%rsp);
818         movq %r11, (1 * 8)(%rsp);
819         movq %r12, (2 * 8)(%rsp);
820         movq %r13, (3 * 8)(%rsp);
821
822         vmovdqu (%rcx), RTMP0x;
823
824         /* Offset_i = Offset_{i-1} xor L_{ntz(i)} */
825         /* C_i = Offset_i xor ENCIPHER(K, P_i xor Offset_i)  */
826
827 #define OCB_INPUT(n, l0reg, l1reg, yreg) \
828           vmovdqu (n * 32)(%rdx), yreg; \
829           vpxor (l0reg), RTMP0x, RNOTx; \
830           vpxor (l1reg), RNOTx, RTMP0x; \
831           vinserti128 $1, RTMP0x, RNOT, RNOT; \
832           vpxor yreg, RNOT, yreg; \
833           vmovdqu RNOT, (n * 32)(%rsi);
834
835         movq (0 * 8)(%r9), %r10;
836         movq (1 * 8)(%r9), %r11;
837         movq (2 * 8)(%r9), %r12;
838         movq (3 * 8)(%r9), %r13;
839         OCB_INPUT(0, %r10, %r11, RA0);
840         OCB_INPUT(1, %r12, %r13, RB0);
841         movq (4 * 8)(%r9), %r10;
842         movq (5 * 8)(%r9), %r11;
843         movq (6 * 8)(%r9), %r12;
844         movq (7 * 8)(%r9), %r13;
845         OCB_INPUT(2, %r10, %r11, RC0);
846         OCB_INPUT(3, %r12, %r13, RD0);
847         movq (8 * 8)(%r9), %r10;
848         movq (9 * 8)(%r9), %r11;
849         movq (10 * 8)(%r9), %r12;
850         movq (11 * 8)(%r9), %r13;
851         OCB_INPUT(4, %r10, %r11, RA1);
852         OCB_INPUT(5, %r12, %r13, RB1);
853         movq (12 * 8)(%r9), %r10;
854         movq (13 * 8)(%r9), %r11;
855         movq (14 * 8)(%r9), %r12;
856         movq (15 * 8)(%r9), %r13;
857         OCB_INPUT(6, %r10, %r11, RC1);
858         OCB_INPUT(7, %r12, %r13, RD1);
859 #undef OCB_INPUT
860
861         vmovdqu RTMP0x, (%rcx);
862         mov %r8, %rcx
863
864         movq (0 * 8)(%rsp), %r10;
865         movq (1 * 8)(%rsp), %r11;
866         movq (2 * 8)(%rsp), %r12;
867         movq (3 * 8)(%rsp), %r13;
868
869         call __twofish_dec_blk16;
870
871         vmovdqu (%rcx), RTMP1x;
872
873         vpxor (0 * 32)(%rsi), RA0, RA0;
874         vpxor (1 * 32)(%rsi), RB0, RB0;
875         vpxor (2 * 32)(%rsi), RC0, RC0;
876         vpxor (3 * 32)(%rsi), RD0, RD0;
877         vpxor (4 * 32)(%rsi), RA1, RA1;
878         vpxor (5 * 32)(%rsi), RB1, RB1;
879         vpxor (6 * 32)(%rsi), RC1, RC1;
880         vpxor (7 * 32)(%rsi), RD1, RD1;
881
882         addq $(4 * 8), %rsp;
883
884         /* Checksum_i = Checksum_{i-1} xor P_i  */
885
886         vmovdqu RA0, (0 * 32)(%rsi);
887         vpxor RA0, RTMP1, RTMP1;
888         vmovdqu RB0, (1 * 32)(%rsi);
889         vpxor RB0, RTMP1, RTMP1;
890         vmovdqu RC0, (2 * 32)(%rsi);
891         vpxor RC0, RTMP1, RTMP1;
892         vmovdqu RD0, (3 * 32)(%rsi);
893         vpxor RD0, RTMP1, RTMP1;
894         vmovdqu RA1, (4 * 32)(%rsi);
895         vpxor RA1, RTMP1, RTMP1;
896         vmovdqu RB1, (5 * 32)(%rsi);
897         vpxor RB1, RTMP1, RTMP1;
898         vmovdqu RC1, (6 * 32)(%rsi);
899         vpxor RC1, RTMP1, RTMP1;
900         vmovdqu RD1, (7 * 32)(%rsi);
901         vpxor RD1, RTMP1, RTMP1;
902
903         vextracti128 $1, RTMP1, RNOTx;
904         vpxor RNOTx, RTMP1x, RTMP1x;
905         vmovdqu RTMP1x, (%rcx);
906
907         vzeroall;
908
909         ret;
910 ELF(.size _gcry_twofish_avx2_ocb_dec,.-_gcry_twofish_avx2_ocb_dec;)
911
912 .align 8
913 .globl _gcry_twofish_avx2_ocb_auth
914 ELF(.type _gcry_twofish_avx2_ocb_auth,@function;)
915
916 _gcry_twofish_avx2_ocb_auth:
917         /* input:
918          *      %rdi: ctx, CTX
919          *      %rsi: abuf (16 blocks)
920          *      %rdx: offset
921          *      %rcx: checksum
922          *      %r8 : L pointers (void *L[16])
923          */
924
925         vzeroupper;
926
927         subq $(4 * 8), %rsp;
928
929         movq %r10, (0 * 8)(%rsp);
930         movq %r11, (1 * 8)(%rsp);
931         movq %r12, (2 * 8)(%rsp);
932         movq %r13, (3 * 8)(%rsp);
933
934         vmovdqu (%rdx), RTMP0x;
935
936         /* Offset_i = Offset_{i-1} xor L_{ntz(i)} */
937         /* Sum_i = Sum_{i-1} xor ENCIPHER(K, A_i xor Offset_i)  */
938
939 #define OCB_INPUT(n, l0reg, l1reg, yreg) \
940           vmovdqu (n * 32)(%rsi), yreg; \
941           vpxor (l0reg), RTMP0x, RNOTx; \
942           vpxor (l1reg), RNOTx, RTMP0x; \
943           vinserti128 $1, RTMP0x, RNOT, RNOT; \
944           vpxor yreg, RNOT, yreg;
945
946         movq (0 * 8)(%r8), %r10;
947         movq (1 * 8)(%r8), %r11;
948         movq (2 * 8)(%r8), %r12;
949         movq (3 * 8)(%r8), %r13;
950         OCB_INPUT(0, %r10, %r11, RA0);
951         OCB_INPUT(1, %r12, %r13, RB0);
952         movq (4 * 8)(%r8), %r10;
953         movq (5 * 8)(%r8), %r11;
954         movq (6 * 8)(%r8), %r12;
955         movq (7 * 8)(%r8), %r13;
956         OCB_INPUT(2, %r10, %r11, RC0);
957         OCB_INPUT(3, %r12, %r13, RD0);
958         movq (8 * 8)(%r8), %r10;
959         movq (9 * 8)(%r8), %r11;
960         movq (10 * 8)(%r8), %r12;
961         movq (11 * 8)(%r8), %r13;
962         OCB_INPUT(4, %r10, %r11, RA1);
963         OCB_INPUT(5, %r12, %r13, RB1);
964         movq (12 * 8)(%r8), %r10;
965         movq (13 * 8)(%r8), %r11;
966         movq (14 * 8)(%r8), %r12;
967         movq (15 * 8)(%r8), %r13;
968         OCB_INPUT(6, %r10, %r11, RC1);
969         OCB_INPUT(7, %r12, %r13, RD1);
970 #undef OCB_INPUT
971
972         vmovdqu RTMP0x, (%rdx);
973
974         movq (0 * 8)(%rsp), %r10;
975         movq (1 * 8)(%rsp), %r11;
976         movq (2 * 8)(%rsp), %r12;
977         movq (3 * 8)(%rsp), %r13;
978
979         call __twofish_enc_blk16;
980
981         vpxor RA0, RB0, RA0;
982         vpxor RC0, RD0, RC0;
983         vpxor RA1, RB1, RA1;
984         vpxor RC1, RD1, RC1;
985
986         vpxor RA0, RC0, RA0;
987         vpxor RA1, RC1, RA1;
988
989         addq $(4 * 8), %rsp;
990
991         vpxor RA1, RA0, RTMP1;
992
993         vextracti128 $1, RTMP1, RNOTx;
994         vpxor (%rcx), RTMP1x, RTMP1x;
995         vpxor RNOTx, RTMP1x, RTMP1x;
996         vmovdqu RTMP1x, (%rcx);
997
998         vzeroall;
999
1000         ret;
1001 ELF(.size _gcry_twofish_avx2_ocb_auth,.-_gcry_twofish_avx2_ocb_auth;)
1002
1003 .align 16
1004
1005 /* For CTR-mode IV byteswap */
1006  _gcry_twofish_bswap128_mask:
1007 .Lbswap128_mask:
1008         .byte 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0
1009 ELF(.size _gcry_twofish_bswap128_mask,.-_gcry_twofish_bswap128_mask;)
1010
1011 #endif /*defined(USE_TWOFISH) && defined(ENABLE_AVX2_SUPPORT)*/
1012 #endif /*__x86_64*/