Enable AMD64 Camellia implementations on WIN64
[libgcrypt.git] / cipher / camellia-aesni-avx-amd64.S
1 /* camellia-avx-aesni-amd64.S  -  AES-NI/AVX implementation of Camellia cipher
2  *
3  * Copyright (C) 2013 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)) && \
25     defined(ENABLE_AESNI_SUPPORT) && defined(ENABLE_AVX_SUPPORT)
26
27 #ifdef __PIC__
28 #  define RIP (%rip)
29 #else
30 #  define RIP
31 #endif
32
33 #ifdef HAVE_COMPATIBLE_GCC_AMD64_PLATFORM_AS
34 # define ELF(...) __VA_ARGS__
35 #else
36 # define ELF(...) /*_*/
37 #endif
38
39 #define CAMELLIA_TABLE_BYTE_LEN 272
40
41 /* struct CAMELLIA_context: */
42 #define key_table 0
43 #define key_bitlength CAMELLIA_TABLE_BYTE_LEN
44
45 /* register macros */
46 #define CTX %rdi
47 #define RIO %r8
48
49 /**********************************************************************
50   helper macros
51  **********************************************************************/
52 #define filter_8bit(x, lo_t, hi_t, mask4bit, tmp0) \
53         vpand x, mask4bit, tmp0; \
54         vpandn x, mask4bit, x; \
55         vpsrld $4, x, x; \
56         \
57         vpshufb tmp0, lo_t, tmp0; \
58         vpshufb x, hi_t, x; \
59         vpxor tmp0, x, x;
60
61 /**********************************************************************
62   16-way camellia
63  **********************************************************************/
64
65 /*
66  * IN:
67  *   x0..x7: byte-sliced AB state
68  *   mem_cd: register pointer storing CD state
69  *   key: index for key material
70  * OUT:
71  *   x0..x7: new byte-sliced CD state
72  */
73 #define roundsm16(x0, x1, x2, x3, x4, x5, x6, x7, t0, t1, t2, t3, t4, t5, t6, \
74                   t7, mem_cd, key) \
75         /* \
76          * S-function with AES subbytes \
77          */ \
78         vmovdqa .Linv_shift_row RIP, t4; \
79         vbroadcastss .L0f0f0f0f RIP, t7; \
80         vmovdqa .Lpre_tf_lo_s1 RIP, t0; \
81         vmovdqa .Lpre_tf_hi_s1 RIP, t1; \
82         \
83         /* AES inverse shift rows */ \
84         vpshufb t4, x0, x0; \
85         vpshufb t4, x7, x7; \
86         vpshufb t4, x1, x1; \
87         vpshufb t4, x4, x4; \
88         vpshufb t4, x2, x2; \
89         vpshufb t4, x5, x5; \
90         vpshufb t4, x3, x3; \
91         vpshufb t4, x6, x6; \
92         \
93         /* prefilter sboxes 1, 2 and 3 */ \
94         vmovdqa .Lpre_tf_lo_s4 RIP, t2; \
95         vmovdqa .Lpre_tf_hi_s4 RIP, t3; \
96         filter_8bit(x0, t0, t1, t7, t6); \
97         filter_8bit(x7, t0, t1, t7, t6); \
98         filter_8bit(x1, t0, t1, t7, t6); \
99         filter_8bit(x4, t0, t1, t7, t6); \
100         filter_8bit(x2, t0, t1, t7, t6); \
101         filter_8bit(x5, t0, t1, t7, t6); \
102         \
103         /* prefilter sbox 4 */ \
104         vpxor t4, t4, t4; \
105         filter_8bit(x3, t2, t3, t7, t6); \
106         filter_8bit(x6, t2, t3, t7, t6); \
107         \
108         /* AES subbytes + AES shift rows */ \
109         vmovdqa .Lpost_tf_lo_s1 RIP, t0; \
110         vmovdqa .Lpost_tf_hi_s1 RIP, t1; \
111         vaesenclast t4, x0, x0; \
112         vaesenclast t4, x7, x7; \
113         vaesenclast t4, x1, x1; \
114         vaesenclast t4, x4, x4; \
115         vaesenclast t4, x2, x2; \
116         vaesenclast t4, x5, x5; \
117         vaesenclast t4, x3, x3; \
118         vaesenclast t4, x6, x6; \
119         \
120         /* postfilter sboxes 1 and 4 */ \
121         vmovdqa .Lpost_tf_lo_s3 RIP, t2; \
122         vmovdqa .Lpost_tf_hi_s3 RIP, t3; \
123         filter_8bit(x0, t0, t1, t7, t6); \
124         filter_8bit(x7, t0, t1, t7, t6); \
125         filter_8bit(x3, t0, t1, t7, t6); \
126         filter_8bit(x6, t0, t1, t7, t6); \
127         \
128         /* postfilter sbox 3 */ \
129         vmovdqa .Lpost_tf_lo_s2 RIP, t4; \
130         vmovdqa .Lpost_tf_hi_s2 RIP, t5; \
131         filter_8bit(x2, t2, t3, t7, t6); \
132         filter_8bit(x5, t2, t3, t7, t6); \
133         \
134         vpxor t6, t6, t6; \
135         vmovq key, t0; \
136         \
137         /* postfilter sbox 2 */ \
138         filter_8bit(x1, t4, t5, t7, t2); \
139         filter_8bit(x4, t4, t5, t7, t2); \
140         \
141         vpsrldq $5, t0, t5; \
142         vpsrldq $1, t0, t1; \
143         vpsrldq $2, t0, t2; \
144         vpsrldq $3, t0, t3; \
145         vpsrldq $4, t0, t4; \
146         vpshufb t6, t0, t0; \
147         vpshufb t6, t1, t1; \
148         vpshufb t6, t2, t2; \
149         vpshufb t6, t3, t3; \
150         vpshufb t6, t4, t4; \
151         vpsrldq $2, t5, t7; \
152         vpshufb t6, t7, t7; \
153         \
154         /* P-function */ \
155         vpxor x5, x0, x0; \
156         vpxor x6, x1, x1; \
157         vpxor x7, x2, x2; \
158         vpxor x4, x3, x3; \
159         \
160         vpxor x2, x4, x4; \
161         vpxor x3, x5, x5; \
162         vpxor x0, x6, x6; \
163         vpxor x1, x7, x7; \
164         \
165         vpxor x7, x0, x0; \
166         vpxor x4, x1, x1; \
167         vpxor x5, x2, x2; \
168         vpxor x6, x3, x3; \
169         \
170         vpxor x3, x4, x4; \
171         vpxor x0, x5, x5; \
172         vpxor x1, x6, x6; \
173         vpxor x2, x7, x7; /* note: high and low parts swapped */ \
174         \
175         /* Add key material and result to CD (x becomes new CD) */ \
176         \
177         vpxor t3, x4, x4; \
178         vpxor 0 * 16(mem_cd), x4, x4; \
179         \
180         vpxor t2, x5, x5; \
181         vpxor 1 * 16(mem_cd), x5, x5; \
182         \
183         vpsrldq $1, t5, t3; \
184         vpshufb t6, t5, t5; \
185         vpshufb t6, t3, t6; \
186         \
187         vpxor t1, x6, x6; \
188         vpxor 2 * 16(mem_cd), x6, x6; \
189         \
190         vpxor t0, x7, x7; \
191         vpxor 3 * 16(mem_cd), x7, x7; \
192         \
193         vpxor t7, x0, x0; \
194         vpxor 4 * 16(mem_cd), x0, x0; \
195         \
196         vpxor t6, x1, x1; \
197         vpxor 5 * 16(mem_cd), x1, x1; \
198         \
199         vpxor t5, x2, x2; \
200         vpxor 6 * 16(mem_cd), x2, x2; \
201         \
202         vpxor t4, x3, x3; \
203         vpxor 7 * 16(mem_cd), x3, x3;
204
205 /*
206  * IN/OUT:
207  *  x0..x7: byte-sliced AB state preloaded
208  *  mem_ab: byte-sliced AB state in memory
209  *  mem_cb: byte-sliced CD state in memory
210  */
211 #define two_roundsm16(x0, x1, x2, x3, x4, x5, x6, x7, y0, y1, y2, y3, y4, y5, \
212                       y6, y7, mem_ab, mem_cd, i, dir, store_ab) \
213         roundsm16(x0, x1, x2, x3, x4, x5, x6, x7, y0, y1, y2, y3, y4, y5, \
214                   y6, y7, mem_cd, (key_table + (i) * 8)(CTX)); \
215         \
216         vmovdqu x4, 0 * 16(mem_cd); \
217         vmovdqu x5, 1 * 16(mem_cd); \
218         vmovdqu x6, 2 * 16(mem_cd); \
219         vmovdqu x7, 3 * 16(mem_cd); \
220         vmovdqu x0, 4 * 16(mem_cd); \
221         vmovdqu x1, 5 * 16(mem_cd); \
222         vmovdqu x2, 6 * 16(mem_cd); \
223         vmovdqu x3, 7 * 16(mem_cd); \
224         \
225         roundsm16(x4, x5, x6, x7, x0, x1, x2, x3, y0, y1, y2, y3, y4, y5, \
226                   y6, y7, mem_ab, (key_table + ((i) + (dir)) * 8)(CTX)); \
227         \
228         store_ab(x0, x1, x2, x3, x4, x5, x6, x7, mem_ab);
229
230 #define dummy_store(x0, x1, x2, x3, x4, x5, x6, x7, mem_ab) /* do nothing */
231
232 #define store_ab_state(x0, x1, x2, x3, x4, x5, x6, x7, mem_ab) \
233         /* Store new AB state */ \
234         vmovdqu x0, 0 * 16(mem_ab); \
235         vmovdqu x1, 1 * 16(mem_ab); \
236         vmovdqu x2, 2 * 16(mem_ab); \
237         vmovdqu x3, 3 * 16(mem_ab); \
238         vmovdqu x4, 4 * 16(mem_ab); \
239         vmovdqu x5, 5 * 16(mem_ab); \
240         vmovdqu x6, 6 * 16(mem_ab); \
241         vmovdqu x7, 7 * 16(mem_ab);
242
243 #define enc_rounds16(x0, x1, x2, x3, x4, x5, x6, x7, y0, y1, y2, y3, y4, y5, \
244                       y6, y7, mem_ab, mem_cd, i) \
245         two_roundsm16(x0, x1, x2, x3, x4, x5, x6, x7, y0, y1, y2, y3, y4, y5, \
246                       y6, y7, mem_ab, mem_cd, (i) + 2, 1, store_ab_state); \
247         two_roundsm16(x0, x1, x2, x3, x4, x5, x6, x7, y0, y1, y2, y3, y4, y5, \
248                       y6, y7, mem_ab, mem_cd, (i) + 4, 1, store_ab_state); \
249         two_roundsm16(x0, x1, x2, x3, x4, x5, x6, x7, y0, y1, y2, y3, y4, y5, \
250                       y6, y7, mem_ab, mem_cd, (i) + 6, 1, dummy_store);
251
252 #define dec_rounds16(x0, x1, x2, x3, x4, x5, x6, x7, y0, y1, y2, y3, y4, y5, \
253                       y6, y7, mem_ab, mem_cd, i) \
254         two_roundsm16(x0, x1, x2, x3, x4, x5, x6, x7, y0, y1, y2, y3, y4, y5, \
255                       y6, y7, mem_ab, mem_cd, (i) + 7, -1, store_ab_state); \
256         two_roundsm16(x0, x1, x2, x3, x4, x5, x6, x7, y0, y1, y2, y3, y4, y5, \
257                       y6, y7, mem_ab, mem_cd, (i) + 5, -1, store_ab_state); \
258         two_roundsm16(x0, x1, x2, x3, x4, x5, x6, x7, y0, y1, y2, y3, y4, y5, \
259                       y6, y7, mem_ab, mem_cd, (i) + 3, -1, dummy_store);
260
261 /*
262  * IN:
263  *  v0..3: byte-sliced 32-bit integers
264  * OUT:
265  *  v0..3: (IN <<< 1)
266  */
267 #define rol32_1_16(v0, v1, v2, v3, t0, t1, t2, zero) \
268         vpcmpgtb v0, zero, t0; \
269         vpaddb v0, v0, v0; \
270         vpabsb t0, t0; \
271         \
272         vpcmpgtb v1, zero, t1; \
273         vpaddb v1, v1, v1; \
274         vpabsb t1, t1; \
275         \
276         vpcmpgtb v2, zero, t2; \
277         vpaddb v2, v2, v2; \
278         vpabsb t2, t2; \
279         \
280         vpor t0, v1, v1; \
281         \
282         vpcmpgtb v3, zero, t0; \
283         vpaddb v3, v3, v3; \
284         vpabsb t0, t0; \
285         \
286         vpor t1, v2, v2; \
287         vpor t2, v3, v3; \
288         vpor t0, v0, v0;
289
290 /*
291  * IN:
292  *   r: byte-sliced AB state in memory
293  *   l: byte-sliced CD state in memory
294  * OUT:
295  *   x0..x7: new byte-sliced CD state
296  */
297 #define fls16(l, l0, l1, l2, l3, l4, l5, l6, l7, r, t0, t1, t2, t3, tt0, \
298               tt1, tt2, tt3, kll, klr, krl, krr) \
299         /* \
300          * t0 = kll; \
301          * t0 &= ll; \
302          * lr ^= rol32(t0, 1); \
303          */ \
304         vpxor tt0, tt0, tt0; \
305         vmovd kll, t0; \
306         vpshufb tt0, t0, t3; \
307         vpsrldq $1, t0, t0; \
308         vpshufb tt0, t0, t2; \
309         vpsrldq $1, t0, t0; \
310         vpshufb tt0, t0, t1; \
311         vpsrldq $1, t0, t0; \
312         vpshufb tt0, t0, t0; \
313         \
314         vpand l0, t0, t0; \
315         vpand l1, t1, t1; \
316         vpand l2, t2, t2; \
317         vpand l3, t3, t3; \
318         \
319         rol32_1_16(t3, t2, t1, t0, tt1, tt2, tt3, tt0); \
320         \
321         vpxor l4, t0, l4; \
322         vmovdqu l4, 4 * 16(l); \
323         vpxor l5, t1, l5; \
324         vmovdqu l5, 5 * 16(l); \
325         vpxor l6, t2, l6; \
326         vmovdqu l6, 6 * 16(l); \
327         vpxor l7, t3, l7; \
328         vmovdqu l7, 7 * 16(l); \
329         \
330         /* \
331          * t2 = krr; \
332          * t2 |= rr; \
333          * rl ^= t2; \
334          */ \
335         \
336         vmovd krr, t0; \
337         vpshufb tt0, t0, t3; \
338         vpsrldq $1, t0, t0; \
339         vpshufb tt0, t0, t2; \
340         vpsrldq $1, t0, t0; \
341         vpshufb tt0, t0, t1; \
342         vpsrldq $1, t0, t0; \
343         vpshufb tt0, t0, t0; \
344         \
345         vpor 4 * 16(r), t0, t0; \
346         vpor 5 * 16(r), t1, t1; \
347         vpor 6 * 16(r), t2, t2; \
348         vpor 7 * 16(r), t3, t3; \
349         \
350         vpxor 0 * 16(r), t0, t0; \
351         vpxor 1 * 16(r), t1, t1; \
352         vpxor 2 * 16(r), t2, t2; \
353         vpxor 3 * 16(r), t3, t3; \
354         vmovdqu t0, 0 * 16(r); \
355         vmovdqu t1, 1 * 16(r); \
356         vmovdqu t2, 2 * 16(r); \
357         vmovdqu t3, 3 * 16(r); \
358         \
359         /* \
360          * t2 = krl; \
361          * t2 &= rl; \
362          * rr ^= rol32(t2, 1); \
363          */ \
364         vmovd krl, t0; \
365         vpshufb tt0, t0, t3; \
366         vpsrldq $1, t0, t0; \
367         vpshufb tt0, t0, t2; \
368         vpsrldq $1, t0, t0; \
369         vpshufb tt0, t0, t1; \
370         vpsrldq $1, t0, t0; \
371         vpshufb tt0, t0, t0; \
372         \
373         vpand 0 * 16(r), t0, t0; \
374         vpand 1 * 16(r), t1, t1; \
375         vpand 2 * 16(r), t2, t2; \
376         vpand 3 * 16(r), t3, t3; \
377         \
378         rol32_1_16(t3, t2, t1, t0, tt1, tt2, tt3, tt0); \
379         \
380         vpxor 4 * 16(r), t0, t0; \
381         vpxor 5 * 16(r), t1, t1; \
382         vpxor 6 * 16(r), t2, t2; \
383         vpxor 7 * 16(r), t3, t3; \
384         vmovdqu t0, 4 * 16(r); \
385         vmovdqu t1, 5 * 16(r); \
386         vmovdqu t2, 6 * 16(r); \
387         vmovdqu t3, 7 * 16(r); \
388         \
389         /* \
390          * t0 = klr; \
391          * t0 |= lr; \
392          * ll ^= t0; \
393          */ \
394         \
395         vmovd klr, t0; \
396         vpshufb tt0, t0, t3; \
397         vpsrldq $1, t0, t0; \
398         vpshufb tt0, t0, t2; \
399         vpsrldq $1, t0, t0; \
400         vpshufb tt0, t0, t1; \
401         vpsrldq $1, t0, t0; \
402         vpshufb tt0, t0, t0; \
403         \
404         vpor l4, t0, t0; \
405         vpor l5, t1, t1; \
406         vpor l6, t2, t2; \
407         vpor l7, t3, t3; \
408         \
409         vpxor l0, t0, l0; \
410         vmovdqu l0, 0 * 16(l); \
411         vpxor l1, t1, l1; \
412         vmovdqu l1, 1 * 16(l); \
413         vpxor l2, t2, l2; \
414         vmovdqu l2, 2 * 16(l); \
415         vpxor l3, t3, l3; \
416         vmovdqu l3, 3 * 16(l);
417
418 #define transpose_4x4(x0, x1, x2, x3, t1, t2) \
419         vpunpckhdq x1, x0, t2; \
420         vpunpckldq x1, x0, x0; \
421         \
422         vpunpckldq x3, x2, t1; \
423         vpunpckhdq x3, x2, x2; \
424         \
425         vpunpckhqdq t1, x0, x1; \
426         vpunpcklqdq t1, x0, x0; \
427         \
428         vpunpckhqdq x2, t2, x3; \
429         vpunpcklqdq x2, t2, x2;
430
431 #define byteslice_16x16b_fast(a0, b0, c0, d0, a1, b1, c1, d1, a2, b2, c2, d2, \
432                               a3, b3, c3, d3, st0, st1) \
433         vmovdqu d2, st0; \
434         vmovdqu d3, st1; \
435         transpose_4x4(a0, a1, a2, a3, d2, d3); \
436         transpose_4x4(b0, b1, b2, b3, d2, d3); \
437         vmovdqu st0, d2; \
438         vmovdqu st1, d3; \
439         \
440         vmovdqu a0, st0; \
441         vmovdqu a1, st1; \
442         transpose_4x4(c0, c1, c2, c3, a0, a1); \
443         transpose_4x4(d0, d1, d2, d3, a0, a1); \
444         \
445         vmovdqu .Lshufb_16x16b RIP, a0; \
446         vmovdqu st1, a1; \
447         vpshufb a0, a2, a2; \
448         vpshufb a0, a3, a3; \
449         vpshufb a0, b0, b0; \
450         vpshufb a0, b1, b1; \
451         vpshufb a0, b2, b2; \
452         vpshufb a0, b3, b3; \
453         vpshufb a0, a1, a1; \
454         vpshufb a0, c0, c0; \
455         vpshufb a0, c1, c1; \
456         vpshufb a0, c2, c2; \
457         vpshufb a0, c3, c3; \
458         vpshufb a0, d0, d0; \
459         vpshufb a0, d1, d1; \
460         vpshufb a0, d2, d2; \
461         vpshufb a0, d3, d3; \
462         vmovdqu d3, st1; \
463         vmovdqu st0, d3; \
464         vpshufb a0, d3, a0; \
465         vmovdqu d2, st0; \
466         \
467         transpose_4x4(a0, b0, c0, d0, d2, d3); \
468         transpose_4x4(a1, b1, c1, d1, d2, d3); \
469         vmovdqu st0, d2; \
470         vmovdqu st1, d3; \
471         \
472         vmovdqu b0, st0; \
473         vmovdqu b1, st1; \
474         transpose_4x4(a2, b2, c2, d2, b0, b1); \
475         transpose_4x4(a3, b3, c3, d3, b0, b1); \
476         vmovdqu st0, b0; \
477         vmovdqu st1, b1; \
478         /* does not adjust output bytes inside vectors */
479
480 #define transpose_8x8b(a, b, c, d, e, f, g, h, t0, t1, t2, t3, t4) \
481         vpunpcklbw a, b, t0; \
482         vpunpckhbw a, b, b; \
483         \
484         vpunpcklbw c, d, t1; \
485         vpunpckhbw c, d, d; \
486         \
487         vpunpcklbw e, f, t2; \
488         vpunpckhbw e, f, f; \
489         \
490         vpunpcklbw g, h, t3; \
491         vpunpckhbw g, h, h; \
492         \
493         vpunpcklwd t0, t1, g; \
494         vpunpckhwd t0, t1, t0; \
495         \
496         vpunpcklwd b, d, t1; \
497         vpunpckhwd b, d, e; \
498         \
499         vpunpcklwd t2, t3, c; \
500         vpunpckhwd t2, t3, t2; \
501         \
502         vpunpcklwd f, h, t3; \
503         vpunpckhwd f, h, b; \
504         \
505         vpunpcklwd e, b, t4; \
506         vpunpckhwd e, b, b; \
507         \
508         vpunpcklwd t1, t3, e; \
509         vpunpckhwd t1, t3, f; \
510         \
511         vmovdqa .Ltranspose_8x8_shuf RIP, t3; \
512         \
513         vpunpcklwd g, c, d; \
514         vpunpckhwd g, c, c; \
515         \
516         vpunpcklwd t0, t2, t1; \
517         vpunpckhwd t0, t2, h; \
518         \
519         vpunpckhqdq b, h, a; \
520         vpshufb t3, a, a; \
521         vpunpcklqdq b, h, b; \
522         vpshufb t3, b, b; \
523         \
524         vpunpckhqdq e, d, g; \
525         vpshufb t3, g, g; \
526         vpunpcklqdq e, d, h; \
527         vpshufb t3, h, h; \
528         \
529         vpunpckhqdq f, c, e; \
530         vpshufb t3, e, e; \
531         vpunpcklqdq f, c, f; \
532         vpshufb t3, f, f; \
533         \
534         vpunpckhqdq t4, t1, c; \
535         vpshufb t3, c, c; \
536         vpunpcklqdq t4, t1, d; \
537         vpshufb t3, d, d;
538
539 /* load blocks to registers and apply pre-whitening */
540 #define inpack16_pre(x0, x1, x2, x3, x4, x5, x6, x7, y0, y1, y2, y3, y4, y5, \
541                      y6, y7, rio, key) \
542         vmovq key, x0; \
543         vpshufb .Lpack_bswap RIP, x0, x0; \
544         \
545         vpxor 0 * 16(rio), x0, y7; \
546         vpxor 1 * 16(rio), x0, y6; \
547         vpxor 2 * 16(rio), x0, y5; \
548         vpxor 3 * 16(rio), x0, y4; \
549         vpxor 4 * 16(rio), x0, y3; \
550         vpxor 5 * 16(rio), x0, y2; \
551         vpxor 6 * 16(rio), x0, y1; \
552         vpxor 7 * 16(rio), x0, y0; \
553         vpxor 8 * 16(rio), x0, x7; \
554         vpxor 9 * 16(rio), x0, x6; \
555         vpxor 10 * 16(rio), x0, x5; \
556         vpxor 11 * 16(rio), x0, x4; \
557         vpxor 12 * 16(rio), x0, x3; \
558         vpxor 13 * 16(rio), x0, x2; \
559         vpxor 14 * 16(rio), x0, x1; \
560         vpxor 15 * 16(rio), x0, x0;
561
562 /* byteslice pre-whitened blocks and store to temporary memory */
563 #define inpack16_post(x0, x1, x2, x3, x4, x5, x6, x7, y0, y1, y2, y3, y4, y5, \
564                       y6, y7, mem_ab, mem_cd) \
565         byteslice_16x16b_fast(x0, x1, x2, x3, x4, x5, x6, x7, y0, y1, y2, y3, \
566                               y4, y5, y6, y7, (mem_ab), (mem_cd)); \
567         \
568         vmovdqu x0, 0 * 16(mem_ab); \
569         vmovdqu x1, 1 * 16(mem_ab); \
570         vmovdqu x2, 2 * 16(mem_ab); \
571         vmovdqu x3, 3 * 16(mem_ab); \
572         vmovdqu x4, 4 * 16(mem_ab); \
573         vmovdqu x5, 5 * 16(mem_ab); \
574         vmovdqu x6, 6 * 16(mem_ab); \
575         vmovdqu x7, 7 * 16(mem_ab); \
576         vmovdqu y0, 0 * 16(mem_cd); \
577         vmovdqu y1, 1 * 16(mem_cd); \
578         vmovdqu y2, 2 * 16(mem_cd); \
579         vmovdqu y3, 3 * 16(mem_cd); \
580         vmovdqu y4, 4 * 16(mem_cd); \
581         vmovdqu y5, 5 * 16(mem_cd); \
582         vmovdqu y6, 6 * 16(mem_cd); \
583         vmovdqu y7, 7 * 16(mem_cd);
584
585 /* de-byteslice, apply post-whitening and store blocks */
586 #define outunpack16(x0, x1, x2, x3, x4, x5, x6, x7, y0, y1, y2, y3, y4, \
587                     y5, y6, y7, key, stack_tmp0, stack_tmp1) \
588         byteslice_16x16b_fast(y0, y4, x0, x4, y1, y5, x1, x5, y2, y6, x2, x6, \
589                               y3, y7, x3, x7, stack_tmp0, stack_tmp1); \
590         \
591         vmovdqu x0, stack_tmp0; \
592         \
593         vmovq key, x0; \
594         vpshufb .Lpack_bswap RIP, x0, x0; \
595         \
596         vpxor x0, y7, y7; \
597         vpxor x0, y6, y6; \
598         vpxor x0, y5, y5; \
599         vpxor x0, y4, y4; \
600         vpxor x0, y3, y3; \
601         vpxor x0, y2, y2; \
602         vpxor x0, y1, y1; \
603         vpxor x0, y0, y0; \
604         vpxor x0, x7, x7; \
605         vpxor x0, x6, x6; \
606         vpxor x0, x5, x5; \
607         vpxor x0, x4, x4; \
608         vpxor x0, x3, x3; \
609         vpxor x0, x2, x2; \
610         vpxor x0, x1, x1; \
611         vpxor stack_tmp0, x0, x0;
612
613 #define write_output(x0, x1, x2, x3, x4, x5, x6, x7, y0, y1, y2, y3, y4, y5, \
614                      y6, y7, rio) \
615         vmovdqu x0, 0 * 16(rio); \
616         vmovdqu x1, 1 * 16(rio); \
617         vmovdqu x2, 2 * 16(rio); \
618         vmovdqu x3, 3 * 16(rio); \
619         vmovdqu x4, 4 * 16(rio); \
620         vmovdqu x5, 5 * 16(rio); \
621         vmovdqu x6, 6 * 16(rio); \
622         vmovdqu x7, 7 * 16(rio); \
623         vmovdqu y0, 8 * 16(rio); \
624         vmovdqu y1, 9 * 16(rio); \
625         vmovdqu y2, 10 * 16(rio); \
626         vmovdqu y3, 11 * 16(rio); \
627         vmovdqu y4, 12 * 16(rio); \
628         vmovdqu y5, 13 * 16(rio); \
629         vmovdqu y6, 14 * 16(rio); \
630         vmovdqu y7, 15 * 16(rio);
631
632 .data
633 .align 16
634
635 #define SHUFB_BYTES(idx) \
636         0 + (idx), 4 + (idx), 8 + (idx), 12 + (idx)
637
638 .Lshufb_16x16b:
639         .byte SHUFB_BYTES(0), SHUFB_BYTES(1), SHUFB_BYTES(2), SHUFB_BYTES(3);
640
641 .Lpack_bswap:
642         .long 0x00010203
643         .long 0x04050607
644         .long 0x80808080
645         .long 0x80808080
646
647 /* For CTR-mode IV byteswap */
648 .Lbswap128_mask:
649         .byte 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0
650
651 /*
652  * pre-SubByte transform
653  *
654  * pre-lookup for sbox1, sbox2, sbox3:
655  *   swap_bitendianness(
656  *       isom_map_camellia_to_aes(
657  *           camellia_f(
658  *               swap_bitendianess(in)
659  *           )
660  *       )
661  *   )
662  *
663  * (note: '⊕ 0xc5' inside camellia_f())
664  */
665 .Lpre_tf_lo_s1:
666         .byte 0x45, 0xe8, 0x40, 0xed, 0x2e, 0x83, 0x2b, 0x86
667         .byte 0x4b, 0xe6, 0x4e, 0xe3, 0x20, 0x8d, 0x25, 0x88
668 .Lpre_tf_hi_s1:
669         .byte 0x00, 0x51, 0xf1, 0xa0, 0x8a, 0xdb, 0x7b, 0x2a
670         .byte 0x09, 0x58, 0xf8, 0xa9, 0x83, 0xd2, 0x72, 0x23
671
672 /*
673  * pre-SubByte transform
674  *
675  * pre-lookup for sbox4:
676  *   swap_bitendianness(
677  *       isom_map_camellia_to_aes(
678  *           camellia_f(
679  *               swap_bitendianess(in <<< 1)
680  *           )
681  *       )
682  *   )
683  *
684  * (note: '⊕ 0xc5' inside camellia_f())
685  */
686 .Lpre_tf_lo_s4:
687         .byte 0x45, 0x40, 0x2e, 0x2b, 0x4b, 0x4e, 0x20, 0x25
688         .byte 0x14, 0x11, 0x7f, 0x7a, 0x1a, 0x1f, 0x71, 0x74
689 .Lpre_tf_hi_s4:
690         .byte 0x00, 0xf1, 0x8a, 0x7b, 0x09, 0xf8, 0x83, 0x72
691         .byte 0xad, 0x5c, 0x27, 0xd6, 0xa4, 0x55, 0x2e, 0xdf
692
693 /*
694  * post-SubByte transform
695  *
696  * post-lookup for sbox1, sbox4:
697  *  swap_bitendianness(
698  *      camellia_h(
699  *          isom_map_aes_to_camellia(
700  *              swap_bitendianness(
701  *                  aes_inverse_affine_transform(in)
702  *              )
703  *          )
704  *      )
705  *  )
706  *
707  * (note: '⊕ 0x6e' inside camellia_h())
708  */
709 .Lpost_tf_lo_s1:
710         .byte 0x3c, 0xcc, 0xcf, 0x3f, 0x32, 0xc2, 0xc1, 0x31
711         .byte 0xdc, 0x2c, 0x2f, 0xdf, 0xd2, 0x22, 0x21, 0xd1
712 .Lpost_tf_hi_s1:
713         .byte 0x00, 0xf9, 0x86, 0x7f, 0xd7, 0x2e, 0x51, 0xa8
714         .byte 0xa4, 0x5d, 0x22, 0xdb, 0x73, 0x8a, 0xf5, 0x0c
715
716 /*
717  * post-SubByte transform
718  *
719  * post-lookup for sbox2:
720  *  swap_bitendianness(
721  *      camellia_h(
722  *          isom_map_aes_to_camellia(
723  *              swap_bitendianness(
724  *                  aes_inverse_affine_transform(in)
725  *              )
726  *          )
727  *      )
728  *  ) <<< 1
729  *
730  * (note: '⊕ 0x6e' inside camellia_h())
731  */
732 .Lpost_tf_lo_s2:
733         .byte 0x78, 0x99, 0x9f, 0x7e, 0x64, 0x85, 0x83, 0x62
734         .byte 0xb9, 0x58, 0x5e, 0xbf, 0xa5, 0x44, 0x42, 0xa3
735 .Lpost_tf_hi_s2:
736         .byte 0x00, 0xf3, 0x0d, 0xfe, 0xaf, 0x5c, 0xa2, 0x51
737         .byte 0x49, 0xba, 0x44, 0xb7, 0xe6, 0x15, 0xeb, 0x18
738
739 /*
740  * post-SubByte transform
741  *
742  * post-lookup for sbox3:
743  *  swap_bitendianness(
744  *      camellia_h(
745  *          isom_map_aes_to_camellia(
746  *              swap_bitendianness(
747  *                  aes_inverse_affine_transform(in)
748  *              )
749  *          )
750  *      )
751  *  ) >>> 1
752  *
753  * (note: '⊕ 0x6e' inside camellia_h())
754  */
755 .Lpost_tf_lo_s3:
756         .byte 0x1e, 0x66, 0xe7, 0x9f, 0x19, 0x61, 0xe0, 0x98
757         .byte 0x6e, 0x16, 0x97, 0xef, 0x69, 0x11, 0x90, 0xe8
758 .Lpost_tf_hi_s3:
759         .byte 0x00, 0xfc, 0x43, 0xbf, 0xeb, 0x17, 0xa8, 0x54
760         .byte 0x52, 0xae, 0x11, 0xed, 0xb9, 0x45, 0xfa, 0x06
761
762 /* For isolating SubBytes from AESENCLAST, inverse shift row */
763 .Linv_shift_row:
764         .byte 0x00, 0x0d, 0x0a, 0x07, 0x04, 0x01, 0x0e, 0x0b
765         .byte 0x08, 0x05, 0x02, 0x0f, 0x0c, 0x09, 0x06, 0x03
766
767 /* shuffle mask for 8x8 byte transpose */
768 .Ltranspose_8x8_shuf:
769         .byte 0, 1, 4, 5, 2, 3, 6, 7, 8+0, 8+1, 8+4, 8+5, 8+2, 8+3, 8+6, 8+7
770
771 .align 4
772 /* 4-bit mask */
773 .L0f0f0f0f:
774         .long 0x0f0f0f0f
775
776 .text
777
778 .align 8
779 ELF(.type   __camellia_enc_blk16,@function;)
780
781 __camellia_enc_blk16:
782         /* input:
783          *      %rdi: ctx, CTX
784          *      %rax: temporary storage, 256 bytes
785          *      %xmm0..%xmm15: 16 plaintext blocks
786          * output:
787          *      %xmm0..%xmm15: 16 encrypted blocks, order swapped:
788          *       7, 8, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8
789          */
790
791         leaq 8 * 16(%rax), %rcx;
792
793         inpack16_post(%xmm0, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5, %xmm6, %xmm7,
794                       %xmm8, %xmm9, %xmm10, %xmm11, %xmm12, %xmm13, %xmm14,
795                       %xmm15, %rax, %rcx);
796
797         enc_rounds16(%xmm0, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5, %xmm6, %xmm7,
798                      %xmm8, %xmm9, %xmm10, %xmm11, %xmm12, %xmm13, %xmm14,
799                      %xmm15, %rax, %rcx, 0);
800
801         fls16(%rax, %xmm0, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5, %xmm6, %xmm7,
802               %rcx, %xmm8, %xmm9, %xmm10, %xmm11, %xmm12, %xmm13, %xmm14,
803               %xmm15,
804               ((key_table + (8) * 8) + 0)(CTX),
805               ((key_table + (8) * 8) + 4)(CTX),
806               ((key_table + (8) * 8) + 8)(CTX),
807               ((key_table + (8) * 8) + 12)(CTX));
808
809         enc_rounds16(%xmm0, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5, %xmm6, %xmm7,
810                      %xmm8, %xmm9, %xmm10, %xmm11, %xmm12, %xmm13, %xmm14,
811                      %xmm15, %rax, %rcx, 8);
812
813         fls16(%rax, %xmm0, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5, %xmm6, %xmm7,
814               %rcx, %xmm8, %xmm9, %xmm10, %xmm11, %xmm12, %xmm13, %xmm14,
815               %xmm15,
816               ((key_table + (16) * 8) + 0)(CTX),
817               ((key_table + (16) * 8) + 4)(CTX),
818               ((key_table + (16) * 8) + 8)(CTX),
819               ((key_table + (16) * 8) + 12)(CTX));
820
821         enc_rounds16(%xmm0, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5, %xmm6, %xmm7,
822                      %xmm8, %xmm9, %xmm10, %xmm11, %xmm12, %xmm13, %xmm14,
823                      %xmm15, %rax, %rcx, 16);
824
825         movl $24, %r8d;
826         cmpl $128, key_bitlength(CTX);
827         jne .Lenc_max32;
828
829 .Lenc_done:
830         /* load CD for output */
831         vmovdqu 0 * 16(%rcx), %xmm8;
832         vmovdqu 1 * 16(%rcx), %xmm9;
833         vmovdqu 2 * 16(%rcx), %xmm10;
834         vmovdqu 3 * 16(%rcx), %xmm11;
835         vmovdqu 4 * 16(%rcx), %xmm12;
836         vmovdqu 5 * 16(%rcx), %xmm13;
837         vmovdqu 6 * 16(%rcx), %xmm14;
838         vmovdqu 7 * 16(%rcx), %xmm15;
839
840         outunpack16(%xmm0, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5, %xmm6, %xmm7,
841                     %xmm8, %xmm9, %xmm10, %xmm11, %xmm12, %xmm13, %xmm14,
842                     %xmm15, (key_table)(CTX, %r8, 8), (%rax), 1 * 16(%rax));
843
844         ret;
845
846 .align 8
847 .Lenc_max32:
848         movl $32, %r8d;
849
850         fls16(%rax, %xmm0, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5, %xmm6, %xmm7,
851               %rcx, %xmm8, %xmm9, %xmm10, %xmm11, %xmm12, %xmm13, %xmm14,
852               %xmm15,
853               ((key_table + (24) * 8) + 0)(CTX),
854               ((key_table + (24) * 8) + 4)(CTX),
855               ((key_table + (24) * 8) + 8)(CTX),
856               ((key_table + (24) * 8) + 12)(CTX));
857
858         enc_rounds16(%xmm0, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5, %xmm6, %xmm7,
859                      %xmm8, %xmm9, %xmm10, %xmm11, %xmm12, %xmm13, %xmm14,
860                      %xmm15, %rax, %rcx, 24);
861
862         jmp .Lenc_done;
863 ELF(.size __camellia_enc_blk16,.-__camellia_enc_blk16;)
864
865 .align 8
866 ELF(.type   __camellia_dec_blk16,@function;)
867
868 __camellia_dec_blk16:
869         /* input:
870          *      %rdi: ctx, CTX
871          *      %rax: temporary storage, 256 bytes
872          *      %r8d: 24 for 16 byte key, 32 for larger
873          *      %xmm0..%xmm15: 16 encrypted blocks
874          * output:
875          *      %xmm0..%xmm15: 16 plaintext blocks, order swapped:
876          *       7, 8, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8
877          */
878
879         leaq 8 * 16(%rax), %rcx;
880
881         inpack16_post(%xmm0, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5, %xmm6, %xmm7,
882                       %xmm8, %xmm9, %xmm10, %xmm11, %xmm12, %xmm13, %xmm14,
883                       %xmm15, %rax, %rcx);
884
885         cmpl $32, %r8d;
886         je .Ldec_max32;
887
888 .Ldec_max24:
889         dec_rounds16(%xmm0, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5, %xmm6, %xmm7,
890                      %xmm8, %xmm9, %xmm10, %xmm11, %xmm12, %xmm13, %xmm14,
891                      %xmm15, %rax, %rcx, 16);
892
893         fls16(%rax, %xmm0, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5, %xmm6, %xmm7,
894               %rcx, %xmm8, %xmm9, %xmm10, %xmm11, %xmm12, %xmm13, %xmm14,
895               %xmm15,
896               ((key_table + (16) * 8) + 8)(CTX),
897               ((key_table + (16) * 8) + 12)(CTX),
898               ((key_table + (16) * 8) + 0)(CTX),
899               ((key_table + (16) * 8) + 4)(CTX));
900
901         dec_rounds16(%xmm0, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5, %xmm6, %xmm7,
902                      %xmm8, %xmm9, %xmm10, %xmm11, %xmm12, %xmm13, %xmm14,
903                      %xmm15, %rax, %rcx, 8);
904
905         fls16(%rax, %xmm0, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5, %xmm6, %xmm7,
906               %rcx, %xmm8, %xmm9, %xmm10, %xmm11, %xmm12, %xmm13, %xmm14,
907               %xmm15,
908               ((key_table + (8) * 8) + 8)(CTX),
909               ((key_table + (8) * 8) + 12)(CTX),
910               ((key_table + (8) * 8) + 0)(CTX),
911               ((key_table + (8) * 8) + 4)(CTX));
912
913         dec_rounds16(%xmm0, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5, %xmm6, %xmm7,
914                      %xmm8, %xmm9, %xmm10, %xmm11, %xmm12, %xmm13, %xmm14,
915                      %xmm15, %rax, %rcx, 0);
916
917         /* load CD for output */
918         vmovdqu 0 * 16(%rcx), %xmm8;
919         vmovdqu 1 * 16(%rcx), %xmm9;
920         vmovdqu 2 * 16(%rcx), %xmm10;
921         vmovdqu 3 * 16(%rcx), %xmm11;
922         vmovdqu 4 * 16(%rcx), %xmm12;
923         vmovdqu 5 * 16(%rcx), %xmm13;
924         vmovdqu 6 * 16(%rcx), %xmm14;
925         vmovdqu 7 * 16(%rcx), %xmm15;
926
927         outunpack16(%xmm0, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5, %xmm6, %xmm7,
928                     %xmm8, %xmm9, %xmm10, %xmm11, %xmm12, %xmm13, %xmm14,
929                     %xmm15, (key_table)(CTX), (%rax), 1 * 16(%rax));
930
931         ret;
932
933 .align 8
934 .Ldec_max32:
935         dec_rounds16(%xmm0, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5, %xmm6, %xmm7,
936                      %xmm8, %xmm9, %xmm10, %xmm11, %xmm12, %xmm13, %xmm14,
937                      %xmm15, %rax, %rcx, 24);
938
939         fls16(%rax, %xmm0, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5, %xmm6, %xmm7,
940               %rcx, %xmm8, %xmm9, %xmm10, %xmm11, %xmm12, %xmm13, %xmm14,
941               %xmm15,
942               ((key_table + (24) * 8) + 8)(CTX),
943               ((key_table + (24) * 8) + 12)(CTX),
944               ((key_table + (24) * 8) + 0)(CTX),
945               ((key_table + (24) * 8) + 4)(CTX));
946
947         jmp .Ldec_max24;
948 ELF(.size __camellia_dec_blk16,.-__camellia_dec_blk16;)
949
950 #define inc_le128(x, minus_one, tmp) \
951         vpcmpeqq minus_one, x, tmp; \
952         vpsubq minus_one, x, x; \
953         vpslldq $8, tmp, tmp; \
954         vpsubq tmp, x, x;
955
956 .align 8
957 .globl _gcry_camellia_aesni_avx_ctr_enc
958 ELF(.type   _gcry_camellia_aesni_avx_ctr_enc,@function;)
959
960 _gcry_camellia_aesni_avx_ctr_enc:
961         /* input:
962          *      %rdi: ctx, CTX
963          *      %rsi: dst (16 blocks)
964          *      %rdx: src (16 blocks)
965          *      %rcx: iv (big endian, 128bit)
966          */
967
968         pushq %rbp;
969         movq %rsp, %rbp;
970
971         vzeroupper;
972
973         subq $(16 * 16), %rsp;
974         andq $~31, %rsp;
975         movq %rsp, %rax;
976
977         vmovdqa .Lbswap128_mask RIP, %xmm14;
978
979         /* load IV and byteswap */
980         vmovdqu (%rcx), %xmm15;
981         vmovdqu %xmm15, 15 * 16(%rax);
982         vpshufb %xmm14, %xmm15, %xmm0; /* be => le */
983
984         vpcmpeqd %xmm15, %xmm15, %xmm15;
985         vpsrldq $8, %xmm15, %xmm15; /* low: -1, high: 0 */
986
987         /* construct IVs */
988         inc_le128(%xmm0, %xmm15, %xmm13);
989         vpshufb %xmm14, %xmm0, %xmm13;
990         vmovdqu %xmm13, 14 * 16(%rax);
991         inc_le128(%xmm0, %xmm15, %xmm13);
992         vpshufb %xmm14, %xmm0, %xmm13;
993         vmovdqu %xmm13, 13 * 16(%rax);
994         inc_le128(%xmm0, %xmm15, %xmm13);
995         vpshufb %xmm14, %xmm0, %xmm12;
996         inc_le128(%xmm0, %xmm15, %xmm13);
997         vpshufb %xmm14, %xmm0, %xmm11;
998         inc_le128(%xmm0, %xmm15, %xmm13);
999         vpshufb %xmm14, %xmm0, %xmm10;
1000         inc_le128(%xmm0, %xmm15, %xmm13);
1001         vpshufb %xmm14, %xmm0, %xmm9;
1002         inc_le128(%xmm0, %xmm15, %xmm13);
1003         vpshufb %xmm14, %xmm0, %xmm8;
1004         inc_le128(%xmm0, %xmm15, %xmm13);
1005         vpshufb %xmm14, %xmm0, %xmm7;
1006         inc_le128(%xmm0, %xmm15, %xmm13);
1007         vpshufb %xmm14, %xmm0, %xmm6;
1008         inc_le128(%xmm0, %xmm15, %xmm13);
1009         vpshufb %xmm14, %xmm0, %xmm5;
1010         inc_le128(%xmm0, %xmm15, %xmm13);
1011         vpshufb %xmm14, %xmm0, %xmm4;
1012         inc_le128(%xmm0, %xmm15, %xmm13);
1013         vpshufb %xmm14, %xmm0, %xmm3;
1014         inc_le128(%xmm0, %xmm15, %xmm13);
1015         vpshufb %xmm14, %xmm0, %xmm2;
1016         inc_le128(%xmm0, %xmm15, %xmm13);
1017         vpshufb %xmm14, %xmm0, %xmm1;
1018         inc_le128(%xmm0, %xmm15, %xmm13);
1019         vmovdqa %xmm0, %xmm13;
1020         vpshufb %xmm14, %xmm0, %xmm0;
1021         inc_le128(%xmm13, %xmm15, %xmm14);
1022         vpshufb .Lbswap128_mask RIP, %xmm13, %xmm13; /* le => be */
1023         vmovdqu %xmm13, (%rcx);
1024
1025         /* inpack16_pre: */
1026         vmovq (key_table)(CTX), %xmm15;
1027         vpshufb .Lpack_bswap RIP, %xmm15, %xmm15;
1028         vpxor %xmm0, %xmm15, %xmm0;
1029         vpxor %xmm1, %xmm15, %xmm1;
1030         vpxor %xmm2, %xmm15, %xmm2;
1031         vpxor %xmm3, %xmm15, %xmm3;
1032         vpxor %xmm4, %xmm15, %xmm4;
1033         vpxor %xmm5, %xmm15, %xmm5;
1034         vpxor %xmm6, %xmm15, %xmm6;
1035         vpxor %xmm7, %xmm15, %xmm7;
1036         vpxor %xmm8, %xmm15, %xmm8;
1037         vpxor %xmm9, %xmm15, %xmm9;
1038         vpxor %xmm10, %xmm15, %xmm10;
1039         vpxor %xmm11, %xmm15, %xmm11;
1040         vpxor %xmm12, %xmm15, %xmm12;
1041         vpxor 13 * 16(%rax), %xmm15, %xmm13;
1042         vpxor 14 * 16(%rax), %xmm15, %xmm14;
1043         vpxor 15 * 16(%rax), %xmm15, %xmm15;
1044
1045         call __camellia_enc_blk16;
1046
1047         vpxor 0 * 16(%rdx), %xmm7, %xmm7;
1048         vpxor 1 * 16(%rdx), %xmm6, %xmm6;
1049         vpxor 2 * 16(%rdx), %xmm5, %xmm5;
1050         vpxor 3 * 16(%rdx), %xmm4, %xmm4;
1051         vpxor 4 * 16(%rdx), %xmm3, %xmm3;
1052         vpxor 5 * 16(%rdx), %xmm2, %xmm2;
1053         vpxor 6 * 16(%rdx), %xmm1, %xmm1;
1054         vpxor 7 * 16(%rdx), %xmm0, %xmm0;
1055         vpxor 8 * 16(%rdx), %xmm15, %xmm15;
1056         vpxor 9 * 16(%rdx), %xmm14, %xmm14;
1057         vpxor 10 * 16(%rdx), %xmm13, %xmm13;
1058         vpxor 11 * 16(%rdx), %xmm12, %xmm12;
1059         vpxor 12 * 16(%rdx), %xmm11, %xmm11;
1060         vpxor 13 * 16(%rdx), %xmm10, %xmm10;
1061         vpxor 14 * 16(%rdx), %xmm9, %xmm9;
1062         vpxor 15 * 16(%rdx), %xmm8, %xmm8;
1063
1064         write_output(%xmm7, %xmm6, %xmm5, %xmm4, %xmm3, %xmm2, %xmm1, %xmm0,
1065                      %xmm15, %xmm14, %xmm13, %xmm12, %xmm11, %xmm10, %xmm9,
1066                      %xmm8, %rsi);
1067
1068         vzeroall;
1069
1070         leave;
1071         ret;
1072 ELF(.size _gcry_camellia_aesni_avx_ctr_enc,.-_gcry_camellia_aesni_avx_ctr_enc;)
1073
1074 .align 8
1075 .globl _gcry_camellia_aesni_avx_cbc_dec
1076 ELF(.type   _gcry_camellia_aesni_avx_cbc_dec,@function;)
1077
1078 _gcry_camellia_aesni_avx_cbc_dec:
1079         /* input:
1080          *      %rdi: ctx, CTX
1081          *      %rsi: dst (16 blocks)
1082          *      %rdx: src (16 blocks)
1083          *      %rcx: iv
1084          */
1085
1086         pushq %rbp;
1087         movq %rsp, %rbp;
1088
1089         vzeroupper;
1090
1091         movq %rcx, %r9;
1092
1093         cmpl $128, key_bitlength(CTX);
1094         movl $32, %r8d;
1095         movl $24, %eax;
1096         cmovel %eax, %r8d; /* max */
1097
1098         inpack16_pre(%xmm0, %xmm1, %xmm2, %xmm3, %xmm4, %xmm5, %xmm6, %xmm7,
1099                      %xmm8, %xmm9, %xmm10, %xmm11, %xmm12, %xmm13, %xmm14,
1100                      %xmm15, %rdx, (key_table)(CTX, %r8, 8));
1101
1102         subq $(16 * 16), %rsp;
1103         andq $~31, %rsp;
1104         movq %rsp, %rax;
1105
1106         call __camellia_dec_blk16;
1107
1108         /* XOR output with IV */
1109         vpxor (%r9), %xmm7, %xmm7;
1110         vpxor (0 * 16)(%rdx), %xmm6, %xmm6;
1111         vpxor (1 * 16)(%rdx), %xmm5, %xmm5;
1112         vpxor (2 * 16)(%rdx), %xmm4, %xmm4;
1113         vpxor (3 * 16)(%rdx), %xmm3, %xmm3;
1114         vpxor (4 * 16)(%rdx), %xmm2, %xmm2;
1115         vpxor (5 * 16)(%rdx), %xmm1, %xmm1;
1116         vpxor (6 * 16)(%rdx), %xmm0, %xmm0;
1117         vpxor (7 * 16)(%rdx), %xmm15, %xmm15;
1118         vpxor (8 * 16)(%rdx), %xmm14, %xmm14;
1119         vpxor (9 * 16)(%rdx), %xmm13, %xmm13;
1120         vpxor (10 * 16)(%rdx), %xmm12, %xmm12;
1121         vpxor (11 * 16)(%rdx), %xmm11, %xmm11;
1122         vpxor (12 * 16)(%rdx), %xmm10, %xmm10;
1123         vpxor (13 * 16)(%rdx), %xmm9, %xmm9;
1124         vpxor (14 * 16)(%rdx), %xmm8, %xmm8;
1125         movq (15 * 16 + 0)(%rdx), %r10;
1126         movq (15 * 16 + 8)(%rdx), %r11;
1127
1128         write_output(%xmm7, %xmm6, %xmm5, %xmm4, %xmm3, %xmm2, %xmm1, %xmm0,
1129                      %xmm15, %xmm14, %xmm13, %xmm12, %xmm11, %xmm10, %xmm9,
1130                      %xmm8, %rsi);
1131
1132         /* store new IV */
1133         movq %r10, (0)(%r9);
1134         movq %r11, (8)(%r9);
1135
1136         vzeroall;
1137
1138         leave;
1139         ret;
1140 ELF(.size _gcry_camellia_aesni_avx_cbc_dec,.-_gcry_camellia_aesni_avx_cbc_dec;)
1141
1142 .align 8
1143 .globl _gcry_camellia_aesni_avx_cfb_dec
1144 ELF(.type   _gcry_camellia_aesni_avx_cfb_dec,@function;)
1145
1146 _gcry_camellia_aesni_avx_cfb_dec:
1147         /* input:
1148          *      %rdi: ctx, CTX
1149          *      %rsi: dst (16 blocks)
1150          *      %rdx: src (16 blocks)
1151          *      %rcx: iv
1152          */
1153
1154         pushq %rbp;
1155         movq %rsp, %rbp;
1156
1157         vzeroupper;
1158
1159         subq $(16 * 16), %rsp;
1160         andq $~31, %rsp;
1161         movq %rsp, %rax;
1162
1163         /* inpack16_pre: */
1164         vmovq (key_table)(CTX), %xmm0;
1165         vpshufb .Lpack_bswap RIP, %xmm0, %xmm0;
1166         vpxor (%rcx), %xmm0, %xmm15;
1167         vmovdqu 15 * 16(%rdx), %xmm1;
1168         vmovdqu %xmm1, (%rcx); /* store new IV */
1169         vpxor 0 * 16(%rdx), %xmm0, %xmm14;
1170         vpxor 1 * 16(%rdx), %xmm0, %xmm13;
1171         vpxor 2 * 16(%rdx), %xmm0, %xmm12;
1172         vpxor 3 * 16(%rdx), %xmm0, %xmm11;
1173         vpxor 4 * 16(%rdx), %xmm0, %xmm10;
1174         vpxor 5 * 16(%rdx), %xmm0, %xmm9;
1175         vpxor 6 * 16(%rdx), %xmm0, %xmm8;
1176         vpxor 7 * 16(%rdx), %xmm0, %xmm7;
1177         vpxor 8 * 16(%rdx), %xmm0, %xmm6;
1178         vpxor 9 * 16(%rdx), %xmm0, %xmm5;
1179         vpxor 10 * 16(%rdx), %xmm0, %xmm4;
1180         vpxor 11 * 16(%rdx), %xmm0, %xmm3;
1181         vpxor 12 * 16(%rdx), %xmm0, %xmm2;
1182         vpxor 13 * 16(%rdx), %xmm0, %xmm1;
1183         vpxor 14 * 16(%rdx), %xmm0, %xmm0;
1184
1185         call __camellia_enc_blk16;
1186
1187         vpxor 0 * 16(%rdx), %xmm7, %xmm7;
1188         vpxor 1 * 16(%rdx), %xmm6, %xmm6;
1189         vpxor 2 * 16(%rdx), %xmm5, %xmm5;
1190         vpxor 3 * 16(%rdx), %xmm4, %xmm4;
1191         vpxor 4 * 16(%rdx), %xmm3, %xmm3;
1192         vpxor 5 * 16(%rdx), %xmm2, %xmm2;
1193         vpxor 6 * 16(%rdx), %xmm1, %xmm1;
1194         vpxor 7 * 16(%rdx), %xmm0, %xmm0;
1195         vpxor 8 * 16(%rdx), %xmm15, %xmm15;
1196         vpxor 9 * 16(%rdx), %xmm14, %xmm14;
1197         vpxor 10 * 16(%rdx), %xmm13, %xmm13;
1198         vpxor 11 * 16(%rdx), %xmm12, %xmm12;
1199         vpxor 12 * 16(%rdx), %xmm11, %xmm11;
1200         vpxor 13 * 16(%rdx), %xmm10, %xmm10;
1201         vpxor 14 * 16(%rdx), %xmm9, %xmm9;
1202         vpxor 15 * 16(%rdx), %xmm8, %xmm8;
1203
1204         write_output(%xmm7, %xmm6, %xmm5, %xmm4, %xmm3, %xmm2, %xmm1, %xmm0,
1205                      %xmm15, %xmm14, %xmm13, %xmm12, %xmm11, %xmm10, %xmm9,
1206                      %xmm8, %rsi);
1207
1208         vzeroall;
1209
1210         leave;
1211         ret;
1212 ELF(.size _gcry_camellia_aesni_avx_cfb_dec,.-_gcry_camellia_aesni_avx_cfb_dec;)
1213
1214 /*
1215  * IN:
1216  *  ab: 64-bit AB state
1217  *  cd: 64-bit CD state
1218  */
1219 #define camellia_f(ab, x, t0, t1, t2, t3, t4, inv_shift_row, sbox4mask, \
1220                    _0f0f0f0fmask, pre_s1lo_mask, pre_s1hi_mask, key) \
1221         vmovq key, t0; \
1222         vpxor x, x, t3; \
1223         \
1224         vpxor ab, t0, x; \
1225         \
1226         /* \
1227          * S-function with AES subbytes \
1228          */ \
1229         \
1230         /* input rotation for sbox4 (<<< 1) */ \
1231         vpand x, sbox4mask, t0; \
1232         vpandn x, sbox4mask, x; \
1233         vpaddw t0, t0, t1; \
1234         vpsrlw $7, t0, t0; \
1235         vpor t0, t1, t0; \
1236         vpand sbox4mask, t0, t0; \
1237         vpor t0, x, x; \
1238         \
1239         vmovdqa .Lpost_tf_lo_s1 RIP, t0; \
1240         vmovdqa .Lpost_tf_hi_s1 RIP, t1; \
1241         \
1242         /* prefilter sboxes */ \
1243         filter_8bit(x, pre_s1lo_mask, pre_s1hi_mask, _0f0f0f0fmask, t2); \
1244         \
1245         /* AES subbytes + AES shift rows + AES inv shift rows */ \
1246         vaesenclast t3, x, x; \
1247         \
1248         /* postfilter sboxes */ \
1249         filter_8bit(x, t0, t1, _0f0f0f0fmask, t2); \
1250         \
1251         /* output rotation for sbox2 (<<< 1) */ \
1252         /* output rotation for sbox3 (>>> 1) */ \
1253         vpshufb inv_shift_row, x, t1; \
1254         vpshufb .Lsp0044440444044404mask RIP, x, t4; \
1255         vpshufb .Lsp1110111010011110mask RIP, x, x; \
1256         vpaddb t1, t1, t2; \
1257         vpsrlw $7, t1, t0; \
1258         vpsllw $7, t1, t3; \
1259         vpor t0, t2, t0; \
1260         vpsrlw $1, t1, t1; \
1261         vpshufb .Lsp0222022222000222mask RIP, t0, t0; \
1262         vpor t1, t3, t1; \
1263         \
1264         vpxor x, t4, t4; \
1265         vpshufb .Lsp3033303303303033mask RIP, t1, t1; \
1266         vpxor t4, t0, t0; \
1267         vpxor t1, t0, t0; \
1268         vpsrldq $8, t0, x; \
1269         vpxor t0, x, x;
1270
1271 #define vec_rol128(in, out, nrol, t0) \
1272         vpshufd $0x4e, in, out; \
1273         vpsllq $(nrol), in, t0; \
1274         vpsrlq $(64-(nrol)), out, out; \
1275         vpaddd t0, out, out;
1276
1277 #define vec_ror128(in, out, nror, t0) \
1278         vpshufd $0x4e, in, out; \
1279         vpsrlq $(nror), in, t0; \
1280         vpsllq $(64-(nror)), out, out; \
1281         vpaddd t0, out, out;
1282
1283 .data
1284
1285 .align 16
1286 .Linv_shift_row_and_unpcklbw:
1287         .byte 0x00, 0xff, 0x0d, 0xff, 0x0a, 0xff, 0x07, 0xff
1288         .byte 0x04, 0xff, 0x01, 0xff, 0x0e, 0xff, 0x0b, 0xff
1289 .Lsp0044440444044404mask:
1290         .long 0xffff0404, 0x0404ff04;
1291         .long 0x0d0dff0d, 0x0d0dff0d;
1292 .Lsp1110111010011110mask:
1293         .long 0x000000ff, 0x000000ff;
1294         .long 0x0bffff0b, 0x0b0b0bff;
1295 .Lsp0222022222000222mask:
1296         .long 0xff060606, 0xff060606;
1297         .long 0x0c0cffff, 0xff0c0c0c;
1298 .Lsp3033303303303033mask:
1299         .long 0x04ff0404, 0x04ff0404;
1300         .long 0xff0a0aff, 0x0aff0a0a;
1301 .Lsbox4_input_mask:
1302         .byte 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00;
1303 .Lsigma1:
1304         .long 0x3BCC908B, 0xA09E667F;
1305 .Lsigma2:
1306         .long 0x4CAA73B2, 0xB67AE858;
1307 .Lsigma3:
1308         .long 0xE94F82BE, 0xC6EF372F;
1309 .Lsigma4:
1310         .long 0xF1D36F1C, 0x54FF53A5;
1311 .Lsigma5:
1312         .long 0xDE682D1D, 0x10E527FA;
1313 .Lsigma6:
1314         .long 0xB3E6C1FD, 0xB05688C2;
1315
1316 .text
1317
1318 .align 8
1319 ELF(.type  __camellia_avx_setup128,@function;)
1320 __camellia_avx_setup128:
1321         /* input:
1322          *      %rdi: ctx, CTX; subkey storage at key_table(CTX)
1323          *      %xmm0: key
1324          */
1325 #define cmll_sub(n, ctx) (key_table+((n)*8))(ctx)
1326 #define KL128 %xmm0
1327 #define KA128 %xmm2
1328
1329         vpshufb .Lbswap128_mask RIP, KL128, KL128;
1330
1331         vmovdqa .Linv_shift_row_and_unpcklbw RIP, %xmm11;
1332         vmovq .Lsbox4_input_mask RIP, %xmm12;
1333         vbroadcastss .L0f0f0f0f RIP, %xmm13;
1334         vmovdqa .Lpre_tf_lo_s1 RIP, %xmm14;
1335         vmovdqa .Lpre_tf_hi_s1 RIP, %xmm15;
1336
1337         /*
1338          * Generate KA
1339          */
1340         vpsrldq $8, KL128, %xmm2;
1341         vmovdqa KL128, %xmm3;
1342         vpslldq $8, %xmm3, %xmm3;
1343         vpsrldq $8, %xmm3, %xmm3;
1344
1345         camellia_f(%xmm2, %xmm4, %xmm1,
1346                    %xmm5, %xmm6, %xmm7, %xmm8,
1347                    %xmm11, %xmm12, %xmm13, %xmm14, %xmm15, .Lsigma1 RIP);
1348         vpxor %xmm4, %xmm3, %xmm3;
1349         camellia_f(%xmm3, %xmm2, %xmm1,
1350                    %xmm5, %xmm6, %xmm7, %xmm8,
1351                    %xmm11, %xmm12, %xmm13, %xmm14, %xmm15, .Lsigma2 RIP);
1352         camellia_f(%xmm2, %xmm3, %xmm1,
1353                    %xmm5, %xmm6, %xmm7, %xmm8,
1354                    %xmm11, %xmm12, %xmm13, %xmm14, %xmm15, .Lsigma3 RIP);
1355         vpxor %xmm4, %xmm3, %xmm3;
1356         camellia_f(%xmm3, %xmm4, %xmm1,
1357                    %xmm5, %xmm6, %xmm7, %xmm8,
1358                    %xmm11, %xmm12, %xmm13, %xmm14, %xmm15, .Lsigma4 RIP);
1359
1360         vpslldq $8, %xmm3, %xmm3;
1361         vpxor %xmm4, %xmm2, %xmm2;
1362         vpsrldq $8, %xmm3, %xmm3;
1363         vpslldq $8, %xmm2, KA128;
1364         vpor %xmm3, KA128, KA128;
1365
1366         /*
1367          * Generate subkeys
1368          */
1369         vmovdqu KA128, cmll_sub(24, CTX);
1370         vec_rol128(KL128, %xmm3, 15, %xmm15);
1371         vec_rol128(KA128, %xmm4, 15, %xmm15);
1372         vec_rol128(KA128, %xmm5, 30, %xmm15);
1373         vec_rol128(KL128, %xmm6, 45, %xmm15);
1374         vec_rol128(KA128, %xmm7, 45, %xmm15);
1375         vec_rol128(KL128, %xmm8, 60, %xmm15);
1376         vec_rol128(KA128, %xmm9, 60, %xmm15);
1377         vec_ror128(KL128, %xmm10, 128-77, %xmm15);
1378
1379         /* absorb kw2 to other subkeys */
1380         vpslldq $8, KL128, %xmm15;
1381         vpsrldq $8, %xmm15, %xmm15;
1382         vpxor %xmm15, KA128, KA128;
1383         vpxor %xmm15, %xmm3, %xmm3;
1384         vpxor %xmm15, %xmm4, %xmm4;
1385
1386         /* subl(1) ^= subr(1) & ~subr(9); */
1387         vpandn %xmm15, %xmm5, %xmm13;
1388         vpslldq $12, %xmm13, %xmm13;
1389         vpsrldq $8, %xmm13, %xmm13;
1390         vpxor %xmm13, %xmm15, %xmm15;
1391         /* dw = subl(1) & subl(9), subr(1) ^= CAMELLIA_RL1(dw); */
1392         vpand %xmm15, %xmm5, %xmm14;
1393         vpslld $1, %xmm14, %xmm11;
1394         vpsrld $31, %xmm14, %xmm14;
1395         vpaddd %xmm11, %xmm14, %xmm14;
1396         vpslldq $8, %xmm14, %xmm14;
1397         vpsrldq $12, %xmm14, %xmm14;
1398         vpxor %xmm14, %xmm15, %xmm15;
1399
1400         vpxor %xmm15, %xmm6, %xmm6;
1401         vpxor %xmm15, %xmm8, %xmm8;
1402         vpxor %xmm15, %xmm9, %xmm9;
1403
1404         /* subl(1) ^= subr(1) & ~subr(17); */
1405         vpandn %xmm15, %xmm10, %xmm13;
1406         vpslldq $12, %xmm13, %xmm13;
1407         vpsrldq $8, %xmm13, %xmm13;
1408         vpxor %xmm13, %xmm15, %xmm15;
1409         /* dw = subl(1) & subl(17), subr(1) ^= CAMELLIA_RL1(dw); */
1410         vpand %xmm15, %xmm10, %xmm14;
1411         vpslld $1, %xmm14, %xmm11;
1412         vpsrld $31, %xmm14, %xmm14;
1413         vpaddd %xmm11, %xmm14, %xmm14;
1414         vpslldq $8, %xmm14, %xmm14;
1415         vpsrldq $12, %xmm14, %xmm14;
1416         vpxor %xmm14, %xmm15, %xmm15;
1417
1418         vpshufd $0x1b, KL128, KL128;
1419         vpshufd $0x1b, KA128, KA128;
1420         vpshufd $0x1b, %xmm3, %xmm3;
1421         vpshufd $0x1b, %xmm4, %xmm4;
1422         vpshufd $0x1b, %xmm5, %xmm5;
1423         vpshufd $0x1b, %xmm6, %xmm6;
1424         vpshufd $0x1b, %xmm7, %xmm7;
1425         vpshufd $0x1b, %xmm8, %xmm8;
1426         vpshufd $0x1b, %xmm9, %xmm9;
1427         vpshufd $0x1b, %xmm10, %xmm10;
1428
1429         vmovdqu KL128, cmll_sub(0, CTX);
1430         vpshufd $0x1b, KL128, KL128;
1431         vmovdqu KA128, cmll_sub(2, CTX);
1432         vmovdqu %xmm3, cmll_sub(4, CTX);
1433         vmovdqu %xmm4, cmll_sub(6, CTX);
1434         vmovdqu %xmm5, cmll_sub(8, CTX);
1435         vmovdqu %xmm6, cmll_sub(10, CTX);
1436         vpsrldq $8, %xmm8, %xmm8;
1437         vmovq %xmm7, cmll_sub(12, CTX);
1438         vmovq %xmm8, cmll_sub(13, CTX);
1439         vmovdqu %xmm9, cmll_sub(14, CTX);
1440         vmovdqu %xmm10, cmll_sub(16, CTX);
1441
1442         vmovdqu cmll_sub(24, CTX), KA128;
1443
1444         vec_ror128(KL128, %xmm3, 128 - 94, %xmm7);
1445         vec_ror128(KA128, %xmm4, 128 - 94, %xmm7);
1446         vec_ror128(KL128, %xmm5, 128 - 111, %xmm7);
1447         vec_ror128(KA128, %xmm6, 128 - 111, %xmm7);
1448
1449         vpxor %xmm15, %xmm3, %xmm3;
1450         vpxor %xmm15, %xmm4, %xmm4;
1451         vpxor %xmm15, %xmm5, %xmm5;
1452         vpslldq $8, %xmm15, %xmm15;
1453         vpxor %xmm15, %xmm6, %xmm6;
1454
1455         /* absorb kw4 to other subkeys */
1456         vpslldq $8, %xmm6, %xmm15;
1457         vpxor %xmm15, %xmm5, %xmm5;
1458         vpxor %xmm15, %xmm4, %xmm4;
1459         vpxor %xmm15, %xmm3, %xmm3;
1460
1461         /* subl(25) ^= subr(25) & ~subr(16); */
1462         vpshufd $0x1b, cmll_sub(16, CTX), %xmm10;
1463         vpandn %xmm15, %xmm10, %xmm13;
1464         vpslldq $4, %xmm13, %xmm13;
1465         vpxor %xmm13, %xmm15, %xmm15;
1466         /* dw = subl(25) & subl(16), subr(25) ^= CAMELLIA_RL1(dw); */
1467         vpand %xmm15, %xmm10, %xmm14;
1468         vpslld $1, %xmm14, %xmm11;
1469         vpsrld $31, %xmm14, %xmm14;
1470         vpaddd %xmm11, %xmm14, %xmm14;
1471         vpsrldq $12, %xmm14, %xmm14;
1472         vpslldq $8, %xmm14, %xmm14;
1473         vpxor %xmm14, %xmm15, %xmm15;
1474
1475         vpshufd $0x1b, %xmm3, %xmm3;
1476         vpshufd $0x1b, %xmm4, %xmm4;
1477         vpshufd $0x1b, %xmm5, %xmm5;
1478         vpshufd $0x1b, %xmm6, %xmm6;
1479
1480         vmovdqu %xmm3, cmll_sub(18, CTX);
1481         vmovdqu %xmm4, cmll_sub(20, CTX);
1482         vmovdqu %xmm5, cmll_sub(22, CTX);
1483         vmovdqu %xmm6, cmll_sub(24, CTX);
1484
1485         vpshufd $0x1b, cmll_sub(14, CTX), %xmm3;
1486         vpshufd $0x1b, cmll_sub(12, CTX), %xmm4;
1487         vpshufd $0x1b, cmll_sub(10, CTX), %xmm5;
1488         vpshufd $0x1b, cmll_sub(8, CTX), %xmm6;
1489
1490         vpxor %xmm15, %xmm3, %xmm3;
1491         vpxor %xmm15, %xmm4, %xmm4;
1492         vpxor %xmm15, %xmm5, %xmm5;
1493
1494         /* subl(25) ^= subr(25) & ~subr(8); */
1495         vpandn %xmm15, %xmm6, %xmm13;
1496         vpslldq $4, %xmm13, %xmm13;
1497         vpxor %xmm13, %xmm15, %xmm15;
1498         /* dw = subl(25) & subl(8), subr(25) ^= CAMELLIA_RL1(dw); */
1499         vpand %xmm15, %xmm6, %xmm14;
1500         vpslld $1, %xmm14, %xmm11;
1501         vpsrld $31, %xmm14, %xmm14;
1502         vpaddd %xmm11, %xmm14, %xmm14;
1503         vpsrldq $12, %xmm14, %xmm14;
1504         vpslldq $8, %xmm14, %xmm14;
1505         vpxor %xmm14, %xmm15, %xmm15;
1506
1507         vpshufd $0x1b, %xmm3, %xmm3;
1508         vpshufd $0x1b, %xmm4, %xmm4;
1509         vpshufd $0x1b, %xmm5, %xmm5;
1510
1511         vmovdqu %xmm3, cmll_sub(14, CTX);
1512         vmovdqu %xmm4, cmll_sub(12, CTX);
1513         vmovdqu %xmm5, cmll_sub(10, CTX);
1514
1515         vpshufd $0x1b, cmll_sub(6, CTX), %xmm6;
1516         vpshufd $0x1b, cmll_sub(4, CTX), %xmm4;
1517         vpshufd $0x1b, cmll_sub(2, CTX), %xmm2;
1518         vpshufd $0x1b, cmll_sub(0, CTX), %xmm0;
1519
1520         vpxor %xmm15, %xmm6, %xmm6;
1521         vpxor %xmm15, %xmm4, %xmm4;
1522         vpxor %xmm15, %xmm2, %xmm2;
1523         vpxor %xmm15, %xmm0, %xmm0;
1524
1525         vpshufd $0x1b, %xmm6, %xmm6;
1526         vpshufd $0x1b, %xmm4, %xmm4;
1527         vpshufd $0x1b, %xmm2, %xmm2;
1528         vpshufd $0x1b, %xmm0, %xmm0;
1529
1530         vpsrldq $8, %xmm2, %xmm3;
1531         vpsrldq $8, %xmm4, %xmm5;
1532         vpsrldq $8, %xmm6, %xmm7;
1533
1534         /*
1535          * key XOR is end of F-function.
1536          */
1537         vpxor %xmm2, %xmm0, %xmm0;
1538         vpxor %xmm4, %xmm2, %xmm2;
1539
1540         vmovq %xmm0, cmll_sub(0, CTX);
1541         vmovq %xmm3, cmll_sub(2, CTX);
1542         vpxor %xmm5, %xmm3, %xmm3;
1543         vpxor %xmm6, %xmm4, %xmm4;
1544         vpxor %xmm7, %xmm5, %xmm5;
1545         vmovq %xmm2, cmll_sub(3, CTX);
1546         vmovq %xmm3, cmll_sub(4, CTX);
1547         vmovq %xmm4, cmll_sub(5, CTX);
1548         vmovq %xmm5, cmll_sub(6, CTX);
1549
1550         vmovq cmll_sub(7, CTX), %xmm7;
1551         vmovq cmll_sub(8, CTX), %xmm8;
1552         vmovq cmll_sub(9, CTX), %xmm9;
1553         vmovq cmll_sub(10, CTX), %xmm10;
1554         /* tl = subl(10) ^ (subr(10) & ~subr(8)); */
1555         vpandn %xmm10, %xmm8, %xmm15;
1556         vpsrldq $4, %xmm15, %xmm15;
1557         vpxor %xmm15, %xmm10, %xmm0;
1558         /* dw = tl & subl(8), tr = subr(10) ^ CAMELLIA_RL1(dw); */
1559         vpand %xmm8, %xmm0, %xmm15;
1560         vpslld $1, %xmm15, %xmm14;
1561         vpsrld $31, %xmm15, %xmm15;
1562         vpaddd %xmm14, %xmm15, %xmm15;
1563         vpslldq $12, %xmm15, %xmm15;
1564         vpsrldq $8, %xmm15, %xmm15;
1565         vpxor %xmm15, %xmm0, %xmm0;
1566
1567         vpxor %xmm0, %xmm6, %xmm6;
1568         vmovq %xmm6, cmll_sub(7, CTX);
1569
1570         vmovq cmll_sub(11, CTX), %xmm11;
1571         vmovq cmll_sub(12, CTX), %xmm12;
1572         vmovq cmll_sub(13, CTX), %xmm13;
1573         vmovq cmll_sub(14, CTX), %xmm14;
1574         vmovq cmll_sub(15, CTX), %xmm15;
1575         /* tl = subl(7) ^ (subr(7) & ~subr(9)); */
1576         vpandn %xmm7, %xmm9, %xmm1;
1577         vpsrldq $4, %xmm1, %xmm1;
1578         vpxor %xmm1, %xmm7, %xmm0;
1579         /* dw = tl & subl(9), tr = subr(7) ^ CAMELLIA_RL1(dw); */
1580         vpand %xmm9, %xmm0, %xmm1;
1581         vpslld $1, %xmm1, %xmm2;
1582         vpsrld $31, %xmm1, %xmm1;
1583         vpaddd %xmm2, %xmm1, %xmm1;
1584         vpslldq $12, %xmm1, %xmm1;
1585         vpsrldq $8, %xmm1, %xmm1;
1586         vpxor %xmm1, %xmm0, %xmm0;
1587
1588         vpxor %xmm11, %xmm0, %xmm0;
1589         vpxor %xmm12, %xmm10, %xmm10;
1590         vpxor %xmm13, %xmm11, %xmm11;
1591         vpxor %xmm14, %xmm12, %xmm12;
1592         vpxor %xmm15, %xmm13, %xmm13;
1593         vmovq %xmm0, cmll_sub(10, CTX);
1594         vmovq %xmm10, cmll_sub(11, CTX);
1595         vmovq %xmm11, cmll_sub(12, CTX);
1596         vmovq %xmm12, cmll_sub(13, CTX);
1597         vmovq %xmm13, cmll_sub(14, CTX);
1598
1599         vmovq cmll_sub(16, CTX), %xmm6;
1600         vmovq cmll_sub(17, CTX), %xmm7;
1601         vmovq cmll_sub(18, CTX), %xmm8;
1602         vmovq cmll_sub(19, CTX), %xmm9;
1603         vmovq cmll_sub(20, CTX), %xmm10;
1604         /* tl = subl(18) ^ (subr(18) & ~subr(16)); */
1605         vpandn %xmm8, %xmm6, %xmm1;
1606         vpsrldq $4, %xmm1, %xmm1;
1607         vpxor %xmm1, %xmm8, %xmm0;
1608         /* dw = tl & subl(16), tr = subr(18) ^ CAMELLIA_RL1(dw); */
1609         vpand %xmm6, %xmm0, %xmm1;
1610         vpslld $1, %xmm1, %xmm2;
1611         vpsrld $31, %xmm1, %xmm1;
1612         vpaddd %xmm2, %xmm1, %xmm1;
1613         vpslldq $12, %xmm1, %xmm1;
1614         vpsrldq $8, %xmm1, %xmm1;
1615         vpxor %xmm1, %xmm0, %xmm0;
1616
1617         vpxor %xmm14, %xmm0, %xmm0;
1618         vmovq %xmm0, cmll_sub(15, CTX);
1619
1620         /* tl = subl(15) ^ (subr(15) & ~subr(17)); */
1621         vpandn %xmm15, %xmm7, %xmm1;
1622         vpsrldq $4, %xmm1, %xmm1;
1623         vpxor %xmm1, %xmm15, %xmm0;
1624         /* dw = tl & subl(17), tr = subr(15) ^ CAMELLIA_RL1(dw); */
1625         vpand %xmm7, %xmm0, %xmm1;
1626         vpslld $1, %xmm1, %xmm2;
1627         vpsrld $31, %xmm1, %xmm1;
1628         vpaddd %xmm2, %xmm1, %xmm1;
1629         vpslldq $12, %xmm1, %xmm1;
1630         vpsrldq $8, %xmm1, %xmm1;
1631         vpxor %xmm1, %xmm0, %xmm0;
1632
1633         vmovq cmll_sub(21, CTX), %xmm1;
1634         vmovq cmll_sub(22, CTX), %xmm2;
1635         vmovq cmll_sub(23, CTX), %xmm3;
1636         vmovq cmll_sub(24, CTX), %xmm4;
1637
1638         vpxor %xmm9, %xmm0, %xmm0;
1639         vpxor %xmm10, %xmm8, %xmm8;
1640         vpxor %xmm1, %xmm9, %xmm9;
1641         vpxor %xmm2, %xmm10, %xmm10;
1642         vpxor %xmm3, %xmm1, %xmm1;
1643         vpxor %xmm4, %xmm3, %xmm3;
1644
1645         vmovq %xmm0, cmll_sub(18, CTX);
1646         vmovq %xmm8, cmll_sub(19, CTX);
1647         vmovq %xmm9, cmll_sub(20, CTX);
1648         vmovq %xmm10, cmll_sub(21, CTX);
1649         vmovq %xmm1, cmll_sub(22, CTX);
1650         vmovq %xmm2, cmll_sub(23, CTX);
1651         vmovq %xmm3, cmll_sub(24, CTX);
1652
1653         /* kw2 and kw4 are unused now. */
1654         movq $0, cmll_sub(1, CTX);
1655         movq $0, cmll_sub(25, CTX);
1656
1657         vzeroall;
1658
1659         ret;
1660 ELF(.size __camellia_avx_setup128,.-__camellia_avx_setup128;)
1661
1662 .align 8
1663 ELF(.type  __camellia_avx_setup256,@function;)
1664
1665 __camellia_avx_setup256:
1666         /* input:
1667          *      %rdi: ctx, CTX; subkey storage at key_table(CTX)
1668          *      %xmm0 & %xmm1: key
1669          */
1670 #define KL128 %xmm0
1671 #define KR128 %xmm1
1672 #define KA128 %xmm2
1673 #define KB128 %xmm3
1674
1675         vpshufb .Lbswap128_mask RIP, KL128, KL128;
1676         vpshufb .Lbswap128_mask RIP, KR128, KR128;
1677
1678         vmovdqa .Linv_shift_row_and_unpcklbw RIP, %xmm11;
1679         vmovq .Lsbox4_input_mask RIP, %xmm12;
1680         vbroadcastss .L0f0f0f0f RIP, %xmm13;
1681         vmovdqa .Lpre_tf_lo_s1 RIP, %xmm14;
1682         vmovdqa .Lpre_tf_hi_s1 RIP, %xmm15;
1683
1684         /*
1685          * Generate KA
1686          */
1687         vpxor KL128, KR128, %xmm3;
1688         vpsrldq $8, KR128, %xmm6;
1689         vpsrldq $8, %xmm3, %xmm2;
1690         vpslldq $8, %xmm3, %xmm3;
1691         vpsrldq $8, %xmm3, %xmm3;
1692
1693         camellia_f(%xmm2, %xmm4, %xmm5,
1694                    %xmm7, %xmm8, %xmm9, %xmm10,
1695                    %xmm11, %xmm12, %xmm13, %xmm14, %xmm15, .Lsigma1 RIP);
1696         vpxor %xmm4, %xmm3, %xmm3;
1697         camellia_f(%xmm3, %xmm2, %xmm5,
1698                    %xmm7, %xmm8, %xmm9, %xmm10,
1699                    %xmm11, %xmm12, %xmm13, %xmm14, %xmm15, .Lsigma2 RIP);
1700         vpxor %xmm6, %xmm2, %xmm2;
1701         camellia_f(%xmm2, %xmm3, %xmm5,
1702                    %xmm7, %xmm8, %xmm9, %xmm10,
1703                    %xmm11, %xmm12, %xmm13, %xmm14, %xmm15, .Lsigma3 RIP);
1704         vpxor %xmm4, %xmm3, %xmm3;
1705         vpxor KR128, %xmm3, %xmm3;
1706         camellia_f(%xmm3, %xmm4, %xmm5,
1707                    %xmm7, %xmm8, %xmm9, %xmm10,
1708                    %xmm11, %xmm12, %xmm13, %xmm14, %xmm15, .Lsigma4 RIP);
1709
1710         vpslldq $8, %xmm3, %xmm3;
1711         vpxor %xmm4, %xmm2, %xmm2;
1712         vpsrldq $8, %xmm3, %xmm3;
1713         vpslldq $8, %xmm2, KA128;
1714         vpor %xmm3, KA128, KA128;
1715
1716         /*
1717          * Generate KB
1718          */
1719         vpxor KA128, KR128, %xmm3;
1720         vpsrldq $8, %xmm3, %xmm4;
1721         vpslldq $8, %xmm3, %xmm3;
1722         vpsrldq $8, %xmm3, %xmm3;
1723
1724         camellia_f(%xmm4, %xmm5, %xmm6,
1725                    %xmm7, %xmm8, %xmm9, %xmm10,
1726                    %xmm11, %xmm12, %xmm13, %xmm14, %xmm15, .Lsigma5 RIP);
1727         vpxor %xmm5, %xmm3, %xmm3;
1728
1729         camellia_f(%xmm3, %xmm5, %xmm6,
1730                    %xmm7, %xmm8, %xmm9, %xmm10,
1731                    %xmm11, %xmm12, %xmm13, %xmm14, %xmm15, .Lsigma6 RIP);
1732         vpslldq $8, %xmm3, %xmm3;
1733         vpxor %xmm5, %xmm4, %xmm4;
1734         vpsrldq $8, %xmm3, %xmm3;
1735         vpslldq $8, %xmm4, %xmm4;
1736         vpor %xmm3, %xmm4, KB128;
1737
1738         /*
1739          * Generate subkeys
1740          */
1741         vmovdqu KB128, cmll_sub(32, CTX);
1742         vec_rol128(KR128, %xmm4, 15, %xmm15);
1743         vec_rol128(KA128, %xmm5, 15, %xmm15);
1744         vec_rol128(KR128, %xmm6, 30, %xmm15);
1745         vec_rol128(KB128, %xmm7, 30, %xmm15);
1746         vec_rol128(KL128, %xmm8, 45, %xmm15);
1747         vec_rol128(KA128, %xmm9, 45, %xmm15);
1748         vec_rol128(KL128, %xmm10, 60, %xmm15);
1749         vec_rol128(KR128, %xmm11, 60, %xmm15);
1750         vec_rol128(KB128, %xmm12, 60, %xmm15);
1751
1752         /* absorb kw2 to other subkeys */
1753         vpslldq $8, KL128, %xmm15;
1754         vpsrldq $8, %xmm15, %xmm15;
1755         vpxor %xmm15, KB128, KB128;
1756         vpxor %xmm15, %xmm4, %xmm4;
1757         vpxor %xmm15, %xmm5, %xmm5;
1758
1759         /* subl(1) ^= subr(1) & ~subr(9); */
1760         vpandn %xmm15, %xmm6, %xmm13;
1761         vpslldq $12, %xmm13, %xmm13;
1762         vpsrldq $8, %xmm13, %xmm13;
1763         vpxor %xmm13, %xmm15, %xmm15;
1764         /* dw = subl(1) & subl(9), subr(1) ^= CAMELLIA_RL1(dw); */
1765         vpand %xmm15, %xmm6, %xmm14;
1766         vpslld $1, %xmm14, %xmm13;
1767         vpsrld $31, %xmm14, %xmm14;
1768         vpaddd %xmm13, %xmm14, %xmm14;
1769         vpslldq $8, %xmm14, %xmm14;
1770         vpsrldq $12, %xmm14, %xmm14;
1771         vpxor %xmm14, %xmm15, %xmm15;
1772
1773         vpxor %xmm15, %xmm7, %xmm7;
1774         vpxor %xmm15, %xmm8, %xmm8;
1775         vpxor %xmm15, %xmm9, %xmm9;
1776
1777         vpshufd $0x1b, KL128, KL128;
1778         vpshufd $0x1b, KB128, KB128;
1779         vpshufd $0x1b, %xmm4, %xmm4;
1780         vpshufd $0x1b, %xmm5, %xmm5;
1781         vpshufd $0x1b, %xmm6, %xmm6;
1782         vpshufd $0x1b, %xmm7, %xmm7;
1783         vpshufd $0x1b, %xmm8, %xmm8;
1784         vpshufd $0x1b, %xmm9, %xmm9;
1785
1786         vmovdqu KL128, cmll_sub(0, CTX);
1787         vpshufd $0x1b, KL128, KL128;
1788         vmovdqu KB128, cmll_sub(2, CTX);
1789         vmovdqu %xmm4, cmll_sub(4, CTX);
1790         vmovdqu %xmm5, cmll_sub(6, CTX);
1791         vmovdqu %xmm6, cmll_sub(8, CTX);
1792         vmovdqu %xmm7, cmll_sub(10, CTX);
1793         vmovdqu %xmm8, cmll_sub(12, CTX);
1794         vmovdqu %xmm9, cmll_sub(14, CTX);
1795
1796         vmovdqu cmll_sub(32, CTX), KB128;
1797
1798         /* subl(1) ^= subr(1) & ~subr(17); */
1799         vpandn %xmm15, %xmm10, %xmm13;
1800         vpslldq $12, %xmm13, %xmm13;
1801         vpsrldq $8, %xmm13, %xmm13;
1802         vpxor %xmm13, %xmm15, %xmm15;
1803         /* dw = subl(1) & subl(17), subr(1) ^= CAMELLIA_RL1(dw); */
1804         vpand %xmm15, %xmm10, %xmm14;
1805         vpslld $1, %xmm14, %xmm13;
1806         vpsrld $31, %xmm14, %xmm14;
1807         vpaddd %xmm13, %xmm14, %xmm14;
1808         vpslldq $8, %xmm14, %xmm14;
1809         vpsrldq $12, %xmm14, %xmm14;
1810         vpxor %xmm14, %xmm15, %xmm15;
1811
1812         vpxor %xmm15, %xmm11, %xmm11;
1813         vpxor %xmm15, %xmm12, %xmm12;
1814
1815         vec_ror128(KL128, %xmm4, 128-77, %xmm14);
1816         vec_ror128(KA128, %xmm5, 128-77, %xmm14);
1817         vec_ror128(KR128, %xmm6, 128-94, %xmm14);
1818         vec_ror128(KA128, %xmm7, 128-94, %xmm14);
1819         vec_ror128(KL128, %xmm8, 128-111, %xmm14);
1820         vec_ror128(KB128, %xmm9, 128-111, %xmm14);
1821
1822         vpxor %xmm15, %xmm4, %xmm4;
1823
1824         vpshufd $0x1b, %xmm10, %xmm10;
1825         vpshufd $0x1b, %xmm11, %xmm11;
1826         vpshufd $0x1b, %xmm12, %xmm12;
1827         vpshufd $0x1b, %xmm4, %xmm4;
1828
1829         vmovdqu %xmm10, cmll_sub(16, CTX);
1830         vmovdqu %xmm11, cmll_sub(18, CTX);
1831         vmovdqu %xmm12, cmll_sub(20, CTX);
1832         vmovdqu %xmm4, cmll_sub(22, CTX);
1833
1834         /* subl(1) ^= subr(1) & ~subr(25); */
1835         vpandn %xmm15, %xmm5, %xmm13;
1836         vpslldq $12, %xmm13, %xmm13;
1837         vpsrldq $8, %xmm13, %xmm13;
1838         vpxor %xmm13, %xmm15, %xmm15;
1839         /* dw = subl(1) & subl(25), subr(1) ^= CAMELLIA_RL1(dw); */
1840         vpand %xmm15, %xmm5, %xmm14;
1841         vpslld $1, %xmm14, %xmm13;
1842         vpsrld $31, %xmm14, %xmm14;
1843         vpaddd %xmm13, %xmm14, %xmm14;
1844         vpslldq $8, %xmm14, %xmm14;
1845         vpsrldq $12, %xmm14, %xmm14;
1846         vpxor %xmm14, %xmm15, %xmm15;
1847
1848         vpxor %xmm15, %xmm6, %xmm6;
1849         vpxor %xmm15, %xmm7, %xmm7;
1850         vpxor %xmm15, %xmm8, %xmm8;
1851         vpslldq $8, %xmm15, %xmm15;
1852         vpxor %xmm15, %xmm9, %xmm9;
1853
1854         /* absorb kw4 to other subkeys */
1855         vpslldq $8, %xmm9, %xmm15;
1856         vpxor %xmm15, %xmm8, %xmm8;
1857         vpxor %xmm15, %xmm7, %xmm7;
1858         vpxor %xmm15, %xmm6, %xmm6;
1859
1860         /* subl(33) ^= subr(33) & ~subr(24); */
1861         vpandn %xmm15, %xmm5, %xmm14;
1862         vpslldq $4, %xmm14, %xmm14;
1863         vpxor %xmm14, %xmm15, %xmm15;
1864         /* dw = subl(33) & subl(24), subr(33) ^= CAMELLIA_RL1(dw); */
1865         vpand %xmm15, %xmm5, %xmm14;
1866         vpslld $1, %xmm14, %xmm13;
1867         vpsrld $31, %xmm14, %xmm14;
1868         vpaddd %xmm13, %xmm14, %xmm14;
1869         vpsrldq $12, %xmm14, %xmm14;
1870         vpslldq $8, %xmm14, %xmm14;
1871         vpxor %xmm14, %xmm15, %xmm15;
1872
1873         vpshufd $0x1b, %xmm5, %xmm5;
1874         vpshufd $0x1b, %xmm6, %xmm6;
1875         vpshufd $0x1b, %xmm7, %xmm7;
1876         vpshufd $0x1b, %xmm8, %xmm8;
1877         vpshufd $0x1b, %xmm9, %xmm9;
1878
1879         vmovdqu %xmm5, cmll_sub(24, CTX);
1880         vmovdqu %xmm6, cmll_sub(26, CTX);
1881         vmovdqu %xmm7, cmll_sub(28, CTX);
1882         vmovdqu %xmm8, cmll_sub(30, CTX);
1883         vmovdqu %xmm9, cmll_sub(32, CTX);
1884
1885         vpshufd $0x1b, cmll_sub(22, CTX), %xmm0;
1886         vpshufd $0x1b, cmll_sub(20, CTX), %xmm1;
1887         vpshufd $0x1b, cmll_sub(18, CTX), %xmm2;
1888         vpshufd $0x1b, cmll_sub(16, CTX), %xmm3;
1889         vpshufd $0x1b, cmll_sub(14, CTX), %xmm4;
1890         vpshufd $0x1b, cmll_sub(12, CTX), %xmm5;
1891         vpshufd $0x1b, cmll_sub(10, CTX), %xmm6;
1892         vpshufd $0x1b, cmll_sub(8, CTX), %xmm7;
1893
1894         vpxor %xmm15, %xmm0, %xmm0;
1895         vpxor %xmm15, %xmm1, %xmm1;
1896         vpxor %xmm15, %xmm2, %xmm2;
1897
1898         /* subl(33) ^= subr(33) & ~subr(24); */
1899         vpandn %xmm15, %xmm3, %xmm14;
1900         vpslldq $4, %xmm14, %xmm14;
1901         vpxor %xmm14, %xmm15, %xmm15;
1902         /* dw = subl(33) & subl(24), subr(33) ^= CAMELLIA_RL1(dw); */
1903         vpand %xmm15, %xmm3, %xmm14;
1904         vpslld $1, %xmm14, %xmm13;
1905         vpsrld $31, %xmm14, %xmm14;
1906         vpaddd %xmm13, %xmm14, %xmm14;
1907         vpsrldq $12, %xmm14, %xmm14;
1908         vpslldq $8, %xmm14, %xmm14;
1909         vpxor %xmm14, %xmm15, %xmm15;
1910
1911         vpxor %xmm15, %xmm4, %xmm4;
1912         vpxor %xmm15, %xmm5, %xmm5;
1913         vpxor %xmm15, %xmm6, %xmm6;
1914
1915         vpshufd $0x1b, %xmm0, %xmm0;
1916         vpshufd $0x1b, %xmm1, %xmm1;
1917         vpshufd $0x1b, %xmm2, %xmm2;
1918         vpshufd $0x1b, %xmm4, %xmm4;
1919         vpshufd $0x1b, %xmm5, %xmm5;
1920         vpshufd $0x1b, %xmm6, %xmm6;
1921
1922         vmovdqu %xmm0, cmll_sub(22, CTX);
1923         vmovdqu %xmm1, cmll_sub(20, CTX);
1924         vmovdqu %xmm2, cmll_sub(18, CTX);
1925         vmovdqu %xmm4, cmll_sub(14, CTX);
1926         vmovdqu %xmm5, cmll_sub(12, CTX);
1927         vmovdqu %xmm6, cmll_sub(10, CTX);
1928
1929         vpshufd $0x1b, cmll_sub(6, CTX), %xmm6;
1930         vpshufd $0x1b, cmll_sub(4, CTX), %xmm4;
1931         vpshufd $0x1b, cmll_sub(2, CTX), %xmm2;
1932         vpshufd $0x1b, cmll_sub(0, CTX), %xmm0;
1933
1934         /* subl(33) ^= subr(33) & ~subr(24); */
1935         vpandn %xmm15, %xmm7, %xmm14;
1936         vpslldq $4, %xmm14, %xmm14;
1937         vpxor %xmm14, %xmm15, %xmm15;
1938         /* dw = subl(33) & subl(24), subr(33) ^= CAMELLIA_RL1(dw); */
1939         vpand %xmm15, %xmm7, %xmm14;
1940         vpslld $1, %xmm14, %xmm13;
1941         vpsrld $31, %xmm14, %xmm14;
1942         vpaddd %xmm13, %xmm14, %xmm14;
1943         vpsrldq $12, %xmm14, %xmm14;
1944         vpslldq $8, %xmm14, %xmm14;
1945         vpxor %xmm14, %xmm15, %xmm15;
1946
1947         vpxor %xmm15, %xmm6, %xmm6;
1948         vpxor %xmm15, %xmm4, %xmm4;
1949         vpxor %xmm15, %xmm2, %xmm2;
1950         vpxor %xmm15, %xmm0, %xmm0;
1951
1952         vpshufd $0x1b, %xmm6, %xmm6;
1953         vpshufd $0x1b, %xmm4, %xmm4;
1954         vpshufd $0x1b, %xmm2, %xmm2;
1955         vpshufd $0x1b, %xmm0, %xmm0;
1956
1957         vpsrldq $8, %xmm2, %xmm3;
1958         vpsrldq $8, %xmm4, %xmm5;
1959         vpsrldq $8, %xmm6, %xmm7;
1960
1961         /*
1962          * key XOR is end of F-function.
1963          */
1964         vpxor %xmm2, %xmm0, %xmm0;
1965         vpxor %xmm4, %xmm2, %xmm2;
1966
1967         vmovq %xmm0, cmll_sub(0, CTX);
1968         vmovq %xmm3, cmll_sub(2, CTX);
1969         vpxor %xmm5, %xmm3, %xmm3;
1970         vpxor %xmm6, %xmm4, %xmm4;
1971         vpxor %xmm7, %xmm5, %xmm5;
1972         vmovq %xmm2, cmll_sub(3, CTX);
1973         vmovq %xmm3, cmll_sub(4, CTX);
1974         vmovq %xmm4, cmll_sub(5, CTX);
1975         vmovq %xmm5, cmll_sub(6, CTX);
1976
1977         vmovq cmll_sub(7, CTX), %xmm7;
1978         vmovq cmll_sub(8, CTX), %xmm8;
1979         vmovq cmll_sub(9, CTX), %xmm9;
1980         vmovq cmll_sub(10, CTX), %xmm10;
1981         /* tl = subl(10) ^ (subr(10) & ~subr(8)); */
1982         vpandn %xmm10, %xmm8, %xmm15;
1983         vpsrldq $4, %xmm15, %xmm15;
1984         vpxor %xmm15, %xmm10, %xmm0;
1985         /* dw = tl & subl(8), tr = subr(10) ^ CAMELLIA_RL1(dw); */
1986         vpand %xmm8, %xmm0, %xmm15;
1987         vpslld $1, %xmm15, %xmm14;
1988         vpsrld $31, %xmm15, %xmm15;
1989         vpaddd %xmm14, %xmm15, %xmm15;
1990         vpslldq $12, %xmm15, %xmm15;
1991         vpsrldq $8, %xmm15, %xmm15;
1992         vpxor %xmm15, %xmm0, %xmm0;
1993
1994         vpxor %xmm0, %xmm6, %xmm6;
1995         vmovq %xmm6, cmll_sub(7, CTX);
1996
1997         vmovq cmll_sub(11, CTX), %xmm11;
1998         vmovq cmll_sub(12, CTX), %xmm12;
1999         vmovq cmll_sub(13, CTX), %xmm13;
2000         vmovq cmll_sub(14, CTX), %xmm14;
2001         vmovq cmll_sub(15, CTX), %xmm15;
2002         /* tl = subl(7) ^ (subr(7) & ~subr(9)); */
2003         vpandn %xmm7, %xmm9, %xmm1;
2004         vpsrldq $4, %xmm1, %xmm1;
2005         vpxor %xmm1, %xmm7, %xmm0;
2006         /* dw = tl & subl(9), tr = subr(7) ^ CAMELLIA_RL1(dw); */
2007         vpand %xmm9, %xmm0, %xmm1;
2008         vpslld $1, %xmm1, %xmm2;
2009         vpsrld $31, %xmm1, %xmm1;
2010         vpaddd %xmm2, %xmm1, %xmm1;
2011         vpslldq $12, %xmm1, %xmm1;
2012         vpsrldq $8, %xmm1, %xmm1;
2013         vpxor %xmm1, %xmm0, %xmm0;
2014
2015         vpxor %xmm11, %xmm0, %xmm0;
2016         vpxor %xmm12, %xmm10, %xmm10;
2017         vpxor %xmm13, %xmm11, %xmm11;
2018         vpxor %xmm14, %xmm12, %xmm12;
2019         vpxor %xmm15, %xmm13, %xmm13;
2020         vmovq %xmm0, cmll_sub(10, CTX);
2021         vmovq %xmm10, cmll_sub(11, CTX);
2022         vmovq %xmm11, cmll_sub(12, CTX);
2023         vmovq %xmm12, cmll_sub(13, CTX);
2024         vmovq %xmm13, cmll_sub(14, CTX);
2025
2026         vmovq cmll_sub(16, CTX), %xmm6;
2027         vmovq cmll_sub(17, CTX), %xmm7;
2028         vmovq cmll_sub(18, CTX), %xmm8;
2029         vmovq cmll_sub(19, CTX), %xmm9;
2030         vmovq cmll_sub(20, CTX), %xmm10;
2031         /* tl = subl(18) ^ (subr(18) & ~subr(16)); */
2032         vpandn %xmm8, %xmm6, %xmm1;
2033         vpsrldq $4, %xmm1, %xmm1;
2034         vpxor %xmm1, %xmm8, %xmm0;
2035         /* dw = tl & subl(16), tr = subr(18) ^ CAMELLIA_RL1(dw); */
2036         vpand %xmm6, %xmm0, %xmm1;
2037         vpslld $1, %xmm1, %xmm2;
2038         vpsrld $31, %xmm1, %xmm1;
2039         vpaddd %xmm2, %xmm1, %xmm1;
2040         vpslldq $12, %xmm1, %xmm1;
2041         vpsrldq $8, %xmm1, %xmm1;
2042         vpxor %xmm1, %xmm0, %xmm0;
2043
2044         vpxor %xmm14, %xmm0, %xmm0;
2045         vmovq %xmm0, cmll_sub(15, CTX);
2046
2047         /* tl = subl(15) ^ (subr(15) & ~subr(17)); */
2048         vpandn %xmm15, %xmm7, %xmm1;
2049         vpsrldq $4, %xmm1, %xmm1;
2050         vpxor %xmm1, %xmm15, %xmm0;
2051         /* dw = tl & subl(17), tr = subr(15) ^ CAMELLIA_RL1(dw); */
2052         vpand %xmm7, %xmm0, %xmm1;
2053         vpslld $1, %xmm1, %xmm2;
2054         vpsrld $31, %xmm1, %xmm1;
2055         vpaddd %xmm2, %xmm1, %xmm1;
2056         vpslldq $12, %xmm1, %xmm1;
2057         vpsrldq $8, %xmm1, %xmm1;
2058         vpxor %xmm1, %xmm0, %xmm0;
2059
2060         vmovq cmll_sub(21, CTX), %xmm1;
2061         vmovq cmll_sub(22, CTX), %xmm2;
2062         vmovq cmll_sub(23, CTX), %xmm3;
2063         vmovq cmll_sub(24, CTX), %xmm4;
2064
2065         vpxor %xmm9, %xmm0, %xmm0;
2066         vpxor %xmm10, %xmm8, %xmm8;
2067         vpxor %xmm1, %xmm9, %xmm9;
2068         vpxor %xmm2, %xmm10, %xmm10;
2069         vpxor %xmm3, %xmm1, %xmm1;
2070
2071         vmovq %xmm0, cmll_sub(18, CTX);
2072         vmovq %xmm8, cmll_sub(19, CTX);
2073         vmovq %xmm9, cmll_sub(20, CTX);
2074         vmovq %xmm10, cmll_sub(21, CTX);
2075         vmovq %xmm1, cmll_sub(22, CTX);
2076
2077         vmovq cmll_sub(25, CTX), %xmm5;
2078         vmovq cmll_sub(26, CTX), %xmm6;
2079         vmovq cmll_sub(27, CTX), %xmm7;
2080         vmovq cmll_sub(28, CTX), %xmm8;
2081         vmovq cmll_sub(29, CTX), %xmm9;
2082         vmovq cmll_sub(30, CTX), %xmm10;
2083         vmovq cmll_sub(31, CTX), %xmm11;
2084         vmovq cmll_sub(32, CTX), %xmm12;
2085
2086         /* tl = subl(26) ^ (subr(26) & ~subr(24)); */
2087         vpandn %xmm6, %xmm4, %xmm15;
2088         vpsrldq $4, %xmm15, %xmm15;
2089         vpxor %xmm15, %xmm6, %xmm0;
2090         /* dw = tl & subl(26), tr = subr(24) ^ CAMELLIA_RL1(dw); */
2091         vpand %xmm4, %xmm0, %xmm15;
2092         vpslld $1, %xmm15, %xmm14;
2093         vpsrld $31, %xmm15, %xmm15;
2094         vpaddd %xmm14, %xmm15, %xmm15;
2095         vpslldq $12, %xmm15, %xmm15;
2096         vpsrldq $8, %xmm15, %xmm15;
2097         vpxor %xmm15, %xmm0, %xmm0;
2098
2099         vpxor %xmm0, %xmm2, %xmm2;
2100         vmovq %xmm2, cmll_sub(23, CTX);
2101
2102         /* tl = subl(23) ^ (subr(23) &  ~subr(25)); */
2103         vpandn %xmm3, %xmm5, %xmm15;
2104         vpsrldq $4, %xmm15, %xmm15;
2105         vpxor %xmm15, %xmm3, %xmm0;
2106         /* dw = tl & subl(26), tr = subr(24) ^ CAMELLIA_RL1(dw); */
2107         vpand %xmm5, %xmm0, %xmm15;
2108         vpslld $1, %xmm15, %xmm14;
2109         vpsrld $31, %xmm15, %xmm15;
2110         vpaddd %xmm14, %xmm15, %xmm15;
2111         vpslldq $12, %xmm15, %xmm15;
2112         vpsrldq $8, %xmm15, %xmm15;
2113         vpxor %xmm15, %xmm0, %xmm0;
2114
2115         vpxor %xmm7, %xmm0, %xmm0;
2116         vpxor %xmm8, %xmm6, %xmm6;
2117         vpxor %xmm9, %xmm7, %xmm7;
2118         vpxor %xmm10, %xmm8, %xmm8;
2119         vpxor %xmm11, %xmm9, %xmm9;
2120         vpxor %xmm12, %xmm11, %xmm11;
2121
2122         vmovq %xmm0, cmll_sub(26, CTX);
2123         vmovq %xmm6, cmll_sub(27, CTX);
2124         vmovq %xmm7, cmll_sub(28, CTX);
2125         vmovq %xmm8, cmll_sub(29, CTX);
2126         vmovq %xmm9, cmll_sub(30, CTX);
2127         vmovq %xmm10, cmll_sub(31, CTX);
2128         vmovq %xmm11, cmll_sub(32, CTX);
2129
2130         /* kw2 and kw4 are unused now. */
2131         movq $0, cmll_sub(1, CTX);
2132         movq $0, cmll_sub(33, CTX);
2133
2134         vzeroall;
2135
2136         ret;
2137 ELF(.size __camellia_avx_setup256,.-__camellia_avx_setup256;)
2138
2139 .align 8
2140 .globl _gcry_camellia_aesni_avx_keygen
2141 ELF(.type  _gcry_camellia_aesni_avx_keygen,@function;)
2142
2143 _gcry_camellia_aesni_avx_keygen:
2144         /* input:
2145          *      %rdi: ctx, CTX
2146          *      %rsi: key
2147          *      %rdx: keylen
2148          */
2149
2150         vzeroupper;
2151
2152         vmovdqu (%rsi), %xmm0;
2153         cmpl $24, %edx;
2154         jb __camellia_avx_setup128;
2155         je .Lprepare_key192;
2156
2157         vmovdqu 16(%rsi), %xmm1;
2158         jmp __camellia_avx_setup256;
2159
2160 .Lprepare_key192:
2161         vpcmpeqd %xmm2, %xmm2, %xmm2;
2162         vmovq 16(%rsi), %xmm1;
2163
2164         vpxor %xmm1, %xmm2, %xmm2;
2165         vpslldq $8, %xmm2, %xmm2;
2166         vpor %xmm2, %xmm1, %xmm1;
2167
2168         jmp __camellia_avx_setup256;
2169 ELF(.size _gcry_camellia_aesni_avx_keygen,.-_gcry_camellia_aesni_avx_keygen;)
2170
2171 #endif /*defined(ENABLE_AESNI_SUPPORT) && defined(ENABLE_AVX_SUPPORT)*/
2172 #endif /*__x86_64*/