SHA-512: Add AVX and AVX2 implementations for x86-64
[libgcrypt.git] / cipher / blowfish-arm.S
1 /* blowfish-arm.S  -  ARM assembly implementation of Blowfish cipher
2  *
3  * Copyright © 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 #include <config.h>
22
23 #if defined(__ARMEL__)
24 #ifdef HAVE_COMPATIBLE_GCC_ARM_PLATFORM_AS
25
26 .text
27
28 .syntax unified
29 .arm
30
31 /* structure of crypto context */
32 #define s0      0
33 #define s1      (s0 + (1 * 256) * 4)
34 #define s2      (s0 + (2 * 256) * 4)
35 #define s3      (s0 + (3 * 256) * 4)
36 #define p       (s3 + (1 * 256) * 4)
37
38 /* register macros */
39 #define CTXs0 %r0
40 #define CTXs1 %r9
41 #define CTXs2 %r8
42 #define CTXs3 %r10
43 #define RMASK %lr
44 #define RKEYL %r2
45 #define RKEYR %ip
46
47 #define RL0 %r3
48 #define RR0 %r4
49
50 #define RL1 %r9
51 #define RR1 %r10
52
53 #define RT0 %r11
54 #define RT1 %r7
55 #define RT2 %r5
56 #define RT3 %r6
57
58 /* helper macros */
59 #define ldr_unaligned_le(rout, rsrc, offs, rtmp) \
60         ldrb rout, [rsrc, #((offs) + 0)]; \
61         ldrb rtmp, [rsrc, #((offs) + 1)]; \
62         orr rout, rout, rtmp, lsl #8; \
63         ldrb rtmp, [rsrc, #((offs) + 2)]; \
64         orr rout, rout, rtmp, lsl #16; \
65         ldrb rtmp, [rsrc, #((offs) + 3)]; \
66         orr rout, rout, rtmp, lsl #24;
67
68 #define str_unaligned_le(rin, rdst, offs, rtmp0, rtmp1) \
69         mov rtmp0, rin, lsr #8; \
70         strb rin, [rdst, #((offs) + 0)]; \
71         mov rtmp1, rin, lsr #16; \
72         strb rtmp0, [rdst, #((offs) + 1)]; \
73         mov rtmp0, rin, lsr #24; \
74         strb rtmp1, [rdst, #((offs) + 2)]; \
75         strb rtmp0, [rdst, #((offs) + 3)];
76
77 #define ldr_unaligned_be(rout, rsrc, offs, rtmp) \
78         ldrb rout, [rsrc, #((offs) + 3)]; \
79         ldrb rtmp, [rsrc, #((offs) + 2)]; \
80         orr rout, rout, rtmp, lsl #8; \
81         ldrb rtmp, [rsrc, #((offs) + 1)]; \
82         orr rout, rout, rtmp, lsl #16; \
83         ldrb rtmp, [rsrc, #((offs) + 0)]; \
84         orr rout, rout, rtmp, lsl #24;
85
86 #define str_unaligned_be(rin, rdst, offs, rtmp0, rtmp1) \
87         mov rtmp0, rin, lsr #8; \
88         strb rin, [rdst, #((offs) + 3)]; \
89         mov rtmp1, rin, lsr #16; \
90         strb rtmp0, [rdst, #((offs) + 2)]; \
91         mov rtmp0, rin, lsr #24; \
92         strb rtmp1, [rdst, #((offs) + 1)]; \
93         strb rtmp0, [rdst, #((offs) + 0)];
94
95 #ifdef __ARMEL__
96         #define ldr_unaligned_host ldr_unaligned_le
97         #define str_unaligned_host str_unaligned_le
98
99         /* bswap on little-endian */
100 #ifdef HAVE_ARM_ARCH_V6
101         #define host_to_be(reg, rtmp) \
102                 rev reg, reg;
103         #define be_to_host(reg, rtmp) \
104                 rev reg, reg;
105 #else
106         #define host_to_be(reg, rtmp) \
107                 eor     rtmp, reg, reg, ror #16; \
108                 mov     rtmp, rtmp, lsr #8; \
109                 bic     rtmp, rtmp, #65280; \
110                 eor     reg, rtmp, reg, ror #8;
111         #define be_to_host(reg, rtmp) \
112                 eor     rtmp, reg, reg, ror #16; \
113                 mov     rtmp, rtmp, lsr #8; \
114                 bic     rtmp, rtmp, #65280; \
115                 eor     reg, rtmp, reg, ror #8;
116 #endif
117 #else
118         #define ldr_unaligned_host ldr_unaligned_be
119         #define str_unaligned_host str_unaligned_be
120
121         /* nop on big-endian */
122         #define host_to_be(reg, rtmp) /*_*/
123         #define be_to_host(reg, rtmp) /*_*/
124 #endif
125
126 #define host_to_host(x, y) /*_*/
127
128 /***********************************************************************
129  * 1-way blowfish
130  ***********************************************************************/
131 #define F(l, r) \
132         and RT0, RMASK, l, lsr#(24 - 2); \
133         and RT1, RMASK, l, lsr#(16 - 2); \
134         ldr RT0, [CTXs0, RT0]; \
135         and RT2, RMASK, l, lsr#(8 - 2); \
136         ldr RT1, [CTXs1, RT1]; \
137         and RT3, RMASK, l, lsl#2; \
138         ldr RT2, [CTXs2, RT2]; \
139         add RT0, RT1; \
140         ldr RT3, [CTXs3, RT3]; \
141         eor RT0, RT2; \
142         add RT0, RT3; \
143         eor r, RT0;
144
145 #define load_roundkey_enc(n) \
146         ldr RKEYL, [CTXs2, #((p - s2) + (4 * (n) + 0))]; \
147         ldr RKEYR, [CTXs2, #((p - s2) + (4 * (n) + 4))];
148
149 #define add_roundkey_enc() \
150         eor RL0, RKEYL; \
151         eor RR0, RKEYR;
152
153 #define round_enc(n) \
154         add_roundkey_enc(); \
155         load_roundkey_enc(n); \
156         \
157         F(RL0, RR0); \
158         F(RR0, RL0);
159
160 #define load_roundkey_dec(n) \
161         ldr RKEYL, [CTXs2, #((p - s2) + (4 * ((n) - 1) + 4))]; \
162         ldr RKEYR, [CTXs2, #((p - s2) + (4 * ((n) - 1) + 0))];
163
164 #define add_roundkey_dec() \
165         eor RL0, RKEYL; \
166         eor RR0, RKEYR;
167
168 #define round_dec(n) \
169         add_roundkey_dec(); \
170         load_roundkey_dec(n); \
171         \
172         F(RL0, RR0); \
173         F(RR0, RL0);
174
175 #define read_block_aligned(rin, offs, l0, r0, convert, rtmp) \
176         ldr l0, [rin, #((offs) + 0)]; \
177         ldr r0, [rin, #((offs) + 4)]; \
178         convert(l0, rtmp); \
179         convert(r0, rtmp);
180
181 #define write_block_aligned(rout, offs, l0, r0, convert, rtmp) \
182         convert(l0, rtmp); \
183         convert(r0, rtmp); \
184         str l0, [rout, #((offs) + 0)]; \
185         str r0, [rout, #((offs) + 4)];
186
187 #ifdef __ARM_FEATURE_UNALIGNED
188         /* unaligned word reads allowed */
189         #define read_block(rin, offs, l0, r0, rtmp0) \
190                 read_block_aligned(rin, offs, l0, r0, host_to_be, rtmp0)
191
192         #define write_block(rout, offs, r0, l0, rtmp0, rtmp1) \
193                 write_block_aligned(rout, offs, r0, l0, be_to_host, rtmp0)
194
195         #define read_block_host(rin, offs, l0, r0, rtmp0) \
196                 read_block_aligned(rin, offs, l0, r0, host_to_host, rtmp0)
197
198         #define write_block_host(rout, offs, r0, l0, rtmp0, rtmp1) \
199                 write_block_aligned(rout, offs, r0, l0, host_to_host, rtmp0)
200 #else
201         /* need to handle unaligned reads by byte reads */
202         #define read_block(rin, offs, l0, r0, rtmp0) \
203                 tst rin, #3; \
204                 beq 1f; \
205                         ldr_unaligned_be(l0, rin, (offs) + 0, rtmp0); \
206                         ldr_unaligned_be(r0, rin, (offs) + 4, rtmp0); \
207                         b 2f; \
208                 1:;\
209                         read_block_aligned(rin, offs, l0, r0, host_to_be, rtmp0); \
210                 2:;
211
212         #define write_block(rout, offs, l0, r0, rtmp0, rtmp1) \
213                 tst rout, #3; \
214                 beq 1f; \
215                         str_unaligned_be(l0, rout, (offs) + 0, rtmp0, rtmp1); \
216                         str_unaligned_be(r0, rout, (offs) + 4, rtmp0, rtmp1); \
217                         b 2f; \
218                 1:;\
219                         write_block_aligned(rout, offs, l0, r0, be_to_host, rtmp0); \
220                 2:;
221
222         #define read_block_host(rin, offs, l0, r0, rtmp0) \
223                 tst rin, #3; \
224                 beq 1f; \
225                         ldr_unaligned_host(l0, rin, (offs) + 0, rtmp0); \
226                         ldr_unaligned_host(r0, rin, (offs) + 4, rtmp0); \
227                         b 2f; \
228                 1:;\
229                         read_block_aligned(rin, offs, l0, r0, host_to_host, rtmp0); \
230                 2:;
231
232         #define write_block_host(rout, offs, l0, r0, rtmp0, rtmp1) \
233                 tst rout, #3; \
234                 beq 1f; \
235                         str_unaligned_host(l0, rout, (offs) + 0, rtmp0, rtmp1); \
236                         str_unaligned_host(r0, rout, (offs) + 4, rtmp0, rtmp1); \
237                         b 2f; \
238                 1:;\
239                         write_block_aligned(rout, offs, l0, r0, host_to_host); \
240                 2:;
241 #endif
242
243 .align 3
244 .type  __blowfish_enc_blk1,%function;
245
246 __blowfish_enc_blk1:
247         /* input:
248          *      preloaded: CTX
249          *      [RL0, RR0]: src
250          * output:
251          *      [RR0, RL0]: dst
252          */
253         push {%lr};
254
255         add CTXs1, CTXs0, #(s1 - s0);
256         add CTXs2, CTXs0, #(s2 - s0);
257         mov RMASK, #(0xff << 2); /* byte mask */
258         add CTXs3, CTXs1, #(s3 - s1);
259
260         load_roundkey_enc(0);
261         round_enc(2);
262         round_enc(4);
263         round_enc(6);
264         round_enc(8);
265         round_enc(10);
266         round_enc(12);
267         round_enc(14);
268         round_enc(16);
269         add_roundkey_enc();
270
271         pop {%pc};
272 .size __blowfish_enc_blk1,.-__blowfish_enc_blk1;
273
274 .align 8
275 .globl  _gcry_blowfish_arm_do_encrypt
276 .type   _gcry_blowfish_arm_do_encrypt,%function;
277
278 _gcry_blowfish_arm_do_encrypt:
279         /* input:
280          *      %r0: ctx, CTX
281          *      %r1: u32 *ret_xl
282          *      %r2: u32 *ret_xr
283          */
284         push {%r2, %r4-%r11, %ip, %lr};
285
286         ldr RL0, [%r1];
287         ldr RR0, [%r2];
288
289         bl __blowfish_enc_blk1;
290
291         pop {%r2};
292         str RR0, [%r1];
293         str RL0, [%r2];
294
295         pop {%r4-%r11, %ip, %pc};
296 .size _gcry_blowfish_arm_do_encrypt,.-_gcry_blowfish_arm_do_encrypt;
297
298 .align 3
299 .globl _gcry_blowfish_arm_encrypt_block
300 .type   _gcry_blowfish_arm_encrypt_block,%function;
301
302 _gcry_blowfish_arm_encrypt_block:
303         /* input:
304          *      %r0: ctx, CTX
305          *      %r1: dst
306          *      %r2: src
307          */
308         push {%r4-%r11, %ip, %lr};
309
310         read_block(%r2, 0, RL0, RR0, RT0);
311
312         bl __blowfish_enc_blk1;
313
314         write_block(%r1, 0, RR0, RL0, RT0, RT1);
315
316         pop {%r4-%r11, %ip, %pc};
317 .size _gcry_blowfish_arm_encrypt_block,.-_gcry_blowfish_arm_encrypt_block;
318
319 .align 3
320 .globl _gcry_blowfish_arm_decrypt_block
321 .type   _gcry_blowfish_arm_decrypt_block,%function;
322
323 _gcry_blowfish_arm_decrypt_block:
324         /* input:
325          *      %r0: ctx, CTX
326          *      %r1: dst
327          *      %r2: src
328          */
329         push {%r4-%r11, %ip, %lr};
330
331         add CTXs1, CTXs0, #(s1 - s0);
332         add CTXs2, CTXs0, #(s2 - s0);
333         mov RMASK, #(0xff << 2); /* byte mask */
334         add CTXs3, CTXs1, #(s3 - s1);
335
336         read_block(%r2, 0, RL0, RR0, RT0);
337
338         load_roundkey_dec(17);
339         round_dec(15);
340         round_dec(13);
341         round_dec(11);
342         round_dec(9);
343         round_dec(7);
344         round_dec(5);
345         round_dec(3);
346         round_dec(1);
347         add_roundkey_dec();
348
349         write_block(%r1, 0, RR0, RL0, RT0, RT1);
350
351         pop {%r4-%r11, %ip, %pc};
352 .size _gcry_blowfish_arm_decrypt_block,.-_gcry_blowfish_arm_decrypt_block;
353
354 /***********************************************************************
355  * 2-way blowfish
356  ***********************************************************************/
357 #define F2(n, l0, r0, l1, r1, set_nextk, dec) \
358         \
359         and RT0, RMASK, l0, lsr#(24 - 2); \
360         and RT1, RMASK, l0, lsr#(16 - 2); \
361         and RT2, RMASK, l0, lsr#(8 - 2); \
362         add RT1, #(s1 - s0); \
363         \
364         ldr RT0, [CTXs0, RT0]; \
365         and RT3, RMASK, l0, lsl#2; \
366         ldr RT1, [CTXs0, RT1]; \
367         add RT3, #(s3 - s2); \
368         ldr RT2, [CTXs2, RT2]; \
369         add RT0, RT1; \
370         ldr RT3, [CTXs2, RT3]; \
371         \
372         and RT1, RMASK, l1, lsr#(24 - 2); \
373         eor RT0, RT2; \
374         and RT2, RMASK, l1, lsr#(16 - 2); \
375         add RT0, RT3; \
376         add RT2, #(s1 - s0); \
377         and RT3, RMASK, l1, lsr#(8 - 2); \
378         eor r0, RT0; \
379         \
380         ldr RT1, [CTXs0, RT1]; \
381         and RT0, RMASK, l1, lsl#2; \
382         ldr RT2, [CTXs0, RT2]; \
383         add RT0, #(s3 - s2); \
384         ldr RT3, [CTXs2, RT3]; \
385         add RT1, RT2; \
386         ldr RT0, [CTXs2, RT0]; \
387         \
388         and RT2, RMASK, r0, lsr#(24 - 2); \
389         eor RT1, RT3; \
390         and RT3, RMASK, r0, lsr#(16 - 2); \
391         add RT1, RT0; \
392         add RT3, #(s1 - s0); \
393         and RT0, RMASK, r0, lsr#(8 - 2); \
394         eor r1, RT1; \
395         \
396         ldr RT2, [CTXs0, RT2]; \
397         and RT1, RMASK, r0, lsl#2; \
398         ldr RT3, [CTXs0, RT3]; \
399         add RT1, #(s3 - s2); \
400         ldr RT0, [CTXs2, RT0]; \
401         add RT2, RT3; \
402         ldr RT1, [CTXs2, RT1]; \
403         \
404         and RT3, RMASK, r1, lsr#(24 - 2); \
405         eor RT2, RT0; \
406         and RT0, RMASK, r1, lsr#(16 - 2); \
407         add RT2, RT1; \
408         add RT0, #(s1 - s0); \
409         and RT1, RMASK, r1, lsr#(8 - 2); \
410         eor l0, RT2; \
411         \
412         ldr RT3, [CTXs0, RT3]; \
413         and RT2, RMASK, r1, lsl#2; \
414         ldr RT0, [CTXs0, RT0]; \
415         add RT2, #(s3 - s2); \
416         ldr RT1, [CTXs2, RT1]; \
417         eor l1, RKEYL; \
418         ldr RT2, [CTXs2, RT2]; \
419         \
420         eor r0, RKEYR; \
421         add RT3, RT0; \
422         eor r1, RKEYR; \
423         eor RT3, RT1; \
424         eor l0, RKEYL; \
425         add RT3, RT2; \
426         set_nextk(RKEYL, (p - s2) + (4 * (n) + ((dec) * 4))); \
427         eor l1, RT3; \
428         set_nextk(RKEYR, (p - s2) + (4 * (n) + (!(dec) * 4)));
429
430 #define load_n_add_roundkey_enc2(n) \
431         load_roundkey_enc(n); \
432         eor RL0, RKEYL; \
433         eor RR0, RKEYR; \
434         eor RL1, RKEYL; \
435         eor RR1, RKEYR; \
436         load_roundkey_enc((n) + 2);
437
438 #define next_key(reg, offs) \
439         ldr reg, [CTXs2, #(offs)];
440
441 #define dummy(x, y) /* do nothing */
442
443 #define round_enc2(n, load_next_key) \
444         F2((n) + 2, RL0, RR0, RL1, RR1, load_next_key, 0);
445
446 #define load_n_add_roundkey_dec2(n) \
447         load_roundkey_dec(n); \
448         eor RL0, RKEYL; \
449         eor RR0, RKEYR; \
450         eor RL1, RKEYL; \
451         eor RR1, RKEYR; \
452         load_roundkey_dec((n) - 2);
453
454 #define round_dec2(n, load_next_key) \
455         F2((n) - 3, RL0, RR0, RL1, RR1, load_next_key, 1);
456
457 #define read_block2_aligned(rin, l0, r0, l1, r1, convert, rtmp) \
458         ldr l0, [rin, #(0)]; \
459         ldr r0, [rin, #(4)]; \
460         convert(l0, rtmp); \
461         ldr l1, [rin, #(8)]; \
462         convert(r0, rtmp); \
463         ldr r1, [rin, #(12)]; \
464         convert(l1, rtmp); \
465         convert(r1, rtmp);
466
467 #define write_block2_aligned(rout, l0, r0, l1, r1, convert, rtmp) \
468         convert(l0, rtmp); \
469         convert(r0, rtmp); \
470         convert(l1, rtmp); \
471         str l0, [rout, #(0)]; \
472         convert(r1, rtmp); \
473         str r0, [rout, #(4)]; \
474         str l1, [rout, #(8)]; \
475         str r1, [rout, #(12)];
476
477 #ifdef __ARM_FEATURE_UNALIGNED
478         /* unaligned word reads allowed */
479         #define read_block2(rin, l0, r0, l1, r1, rtmp0) \
480                 read_block2_aligned(rin, l0, r0, l1, r1, host_to_be, rtmp0)
481
482         #define write_block2(rout, l0, r0, l1, r1, rtmp0, rtmp1) \
483                 write_block2_aligned(rout, l0, r0, l1, r1, be_to_host, rtmp0)
484
485         #define read_block2_host(rin, l0, r0, l1, r1, rtmp0) \
486                 read_block2_aligned(rin, l0, r0, l1, r1, host_to_host, rtmp0)
487
488         #define write_block2_host(rout, l0, r0, l1, r1, rtmp0, rtmp1) \
489                 write_block2_aligned(rout, l0, r0, l1, r1, host_to_host, rtmp0)
490 #else
491         /* need to handle unaligned reads by byte reads */
492         #define read_block2(rin, l0, r0, l1, r1, rtmp0) \
493                 tst rin, #3; \
494                 beq 1f; \
495                         ldr_unaligned_be(l0, rin, 0, rtmp0); \
496                         ldr_unaligned_be(r0, rin, 4, rtmp0); \
497                         ldr_unaligned_be(l1, rin, 8, rtmp0); \
498                         ldr_unaligned_be(r1, rin, 12, rtmp0); \
499                         b 2f; \
500                 1:;\
501                         read_block2_aligned(rin, l0, r0, l1, r1, host_to_be, rtmp0); \
502                 2:;
503
504         #define write_block2(rout, l0, r0, l1, r1, rtmp0, rtmp1) \
505                 tst rout, #3; \
506                 beq 1f; \
507                         str_unaligned_be(l0, rout, 0, rtmp0, rtmp1); \
508                         str_unaligned_be(r0, rout, 4, rtmp0, rtmp1); \
509                         str_unaligned_be(l1, rout, 8, rtmp0, rtmp1); \
510                         str_unaligned_be(r1, rout, 12, rtmp0, rtmp1); \
511                         b 2f; \
512                 1:;\
513                         write_block2_aligned(rout, l0, r0, l1, r1, be_to_host, rtmp0); \
514                 2:;
515
516         #define read_block2_host(rin, l0, r0, l1, r1, rtmp0) \
517                 tst rin, #3; \
518                 beq 1f; \
519                         ldr_unaligned_host(l0, rin, 0, rtmp0); \
520                         ldr_unaligned_host(r0, rin, 4, rtmp0); \
521                         ldr_unaligned_host(l1, rin, 8, rtmp0); \
522                         ldr_unaligned_host(r1, rin, 12, rtmp0); \
523                         b 2f; \
524                 1:;\
525                         read_block2_aligned(rin, l0, r0, l1, r1, host_to_host, rtmp0); \
526                 2:;
527
528         #define write_block2_host(rout, l0, r0, l1, r1, rtmp0, rtmp1) \
529                 tst rout, #3; \
530                 beq 1f; \
531                         str_unaligned_host(l0, rout, 0, rtmp0, rtmp1); \
532                         str_unaligned_host(r0, rout, 4, rtmp0, rtmp1); \
533                         str_unaligned_host(l1, rout, 8, rtmp0, rtmp1); \
534                         str_unaligned_host(r1, rout, 12, rtmp0, rtmp1); \
535                         b 2f; \
536                 1:;\
537                         write_block2_aligned(rout, l0, r0, l1, r1, host_to_host, rtmp0); \
538                 2:;
539 #endif
540
541 .align 3
542 .type  _gcry_blowfish_arm_enc_blk2,%function;
543
544 _gcry_blowfish_arm_enc_blk2:
545         /* input:
546          *      preloaded: CTX
547          *      [RL0, RR0], [RL1, RR1]: src
548          * output:
549          *      [RR0, RL0], [RR1, RL1]: dst
550          */
551         push {RT0,%lr};
552
553         add CTXs2, CTXs0, #(s2 - s0);
554         mov RMASK, #(0xff << 2); /* byte mask */
555
556         load_n_add_roundkey_enc2(0);
557         round_enc2(2, next_key);
558         round_enc2(4, next_key);
559         round_enc2(6, next_key);
560         round_enc2(8, next_key);
561         round_enc2(10, next_key);
562         round_enc2(12, next_key);
563         round_enc2(14, next_key);
564         round_enc2(16, dummy);
565
566         host_to_be(RR0, RT0);
567         host_to_be(RL0, RT0);
568         host_to_be(RR1, RT0);
569         host_to_be(RL1, RT0);
570
571         pop {RT0,%pc};
572 .size _gcry_blowfish_arm_enc_blk2,.-_gcry_blowfish_arm_enc_blk2;
573
574 .align 3
575 .globl _gcry_blowfish_arm_cfb_dec;
576 .type  _gcry_blowfish_arm_cfb_dec,%function;
577
578 _gcry_blowfish_arm_cfb_dec:
579         /* input:
580          *      %r0: CTX
581          *      %r1: dst (2 blocks)
582          *      %r2: src (2 blocks)
583          *      %r3: iv (64bit)
584          */
585         push {%r2, %r4-%r11, %ip, %lr};
586
587         mov %lr, %r3;
588
589         /* Load input (iv/%r3 is aligned, src/%r2 might not be) */
590         ldm %r3, {RL0, RR0};
591         host_to_be(RL0, RT0);
592         host_to_be(RR0, RT0);
593         read_block(%r2, 0, RL1, RR1, RT0);
594
595         /* Update IV, load src[1] and save to iv[0] */
596         read_block_host(%r2, 8, %r5, %r6, RT0);
597         stm %lr, {%r5, %r6};
598
599         bl _gcry_blowfish_arm_enc_blk2;
600         /* result in RR0:RL0, RR1:RL1 = %r4:%r3, %r10:%r9 */
601
602         /* %r1: dst, %r0: %src */
603         pop {%r0};
604
605         /* dst = src ^ result */
606         read_block2_host(%r0, %r5, %r6, %r7, %r8, %lr);
607         eor %r5, %r4;
608         eor %r6, %r3;
609         eor %r7, %r10;
610         eor %r8, %r9;
611         write_block2_host(%r1, %r5, %r6, %r7, %r8, %r9, %r10);
612
613         pop {%r4-%r11, %ip, %pc};
614 .ltorg
615 .size _gcry_blowfish_arm_cfb_dec,.-_gcry_blowfish_arm_cfb_dec;
616
617 .align 3
618 .globl _gcry_blowfish_arm_ctr_enc;
619 .type  _gcry_blowfish_arm_ctr_enc,%function;
620
621 _gcry_blowfish_arm_ctr_enc:
622         /* input:
623          *      %r0: CTX
624          *      %r1: dst (2 blocks)
625          *      %r2: src (2 blocks)
626          *      %r3: iv (64bit, big-endian)
627          */
628         push {%r2, %r4-%r11, %ip, %lr};
629
630         mov %lr, %r3;
631
632         /* Load IV (big => host endian) */
633         read_block_aligned(%lr, 0, RL0, RR0, be_to_host, RT0);
634
635         /* Construct IVs */
636         adds RR1, RR0, #1; /* +1 */
637         adc RL1, RL0, #0;
638         adds %r6, RR1, #1; /* +2 */
639         adc %r5, RL1, #0;
640
641         /* Store new IV (host => big-endian) */
642         write_block_aligned(%lr, 0, %r5, %r6, host_to_be, RT0);
643
644         bl _gcry_blowfish_arm_enc_blk2;
645         /* result in RR0:RL0, RR1:RL1 = %r4:%r3, %r10:%r9 */
646
647         /* %r1: dst, %r0: %src */
648         pop {%r0};
649
650         /* XOR key-stream with plaintext */
651         read_block2_host(%r0, %r5, %r6, %r7, %r8, %lr);
652         eor %r5, %r4;
653         eor %r6, %r3;
654         eor %r7, %r10;
655         eor %r8, %r9;
656         write_block2_host(%r1, %r5, %r6, %r7, %r8, %r9, %r10);
657
658         pop {%r4-%r11, %ip, %pc};
659 .ltorg
660 .size _gcry_blowfish_arm_ctr_enc,.-_gcry_blowfish_arm_ctr_enc;
661
662 .align 3
663 .type  _gcry_blowfish_arm_dec_blk2,%function;
664
665 _gcry_blowfish_arm_dec_blk2:
666         /* input:
667          *      preloaded: CTX
668          *      [RL0, RR0], [RL1, RR1]: src
669          * output:
670          *      [RR0, RL0], [RR1, RL1]: dst
671          */
672         add CTXs2, CTXs0, #(s2 - s0);
673         mov RMASK, #(0xff << 2); /* byte mask */
674
675         load_n_add_roundkey_dec2(17);
676         round_dec2(15, next_key);
677         round_dec2(13, next_key);
678         round_dec2(11, next_key);
679         round_dec2(9, next_key);
680         round_dec2(7, next_key);
681         round_dec2(5, next_key);
682         round_dec2(3, next_key);
683         round_dec2(1, dummy);
684
685         host_to_be(RR0, RT0);
686         host_to_be(RL0, RT0);
687         host_to_be(RR1, RT0);
688         host_to_be(RL1, RT0);
689
690         b .Ldec_cbc_tail;
691 .ltorg
692 .size _gcry_blowfish_arm_dec_blk2,.-_gcry_blowfish_arm_dec_blk2;
693
694 .align 3
695 .globl _gcry_blowfish_arm_cbc_dec;
696 .type  _gcry_blowfish_arm_cbc_dec,%function;
697
698 _gcry_blowfish_arm_cbc_dec:
699         /* input:
700          *      %r0: CTX
701          *      %r1: dst (2 blocks)
702          *      %r2: src (2 blocks)
703          *      %r3: iv (64bit)
704          */
705         push {%r2-%r11, %ip, %lr};
706
707         read_block2(%r2, RL0, RR0, RL1, RR1, RT0);
708
709         /* dec_blk2 is only used by cbc_dec, jump directly in/out instead
710          * of function call. */
711         b _gcry_blowfish_arm_dec_blk2;
712 .Ldec_cbc_tail:
713         /* result in RR0:RL0, RR1:RL1 = %r4:%r3, %r10:%r9 */
714
715         /* %r0: %src, %r1: dst, %r2: iv */
716         pop {%r0, %r2};
717
718         /* load IV+1 (src[0]) to %r7:%r8. Might be unaligned. */
719         read_block_host(%r0, 0, %r7, %r8, %r5);
720         /* load IV (iv[0]) to %r5:%r6. 'iv' is aligned. */
721         ldm %r2, {%r5, %r6};
722
723         /* out[1] ^= IV+1 */
724         eor %r10, %r7;
725         eor %r9, %r8;
726         /* out[0] ^= IV */
727         eor %r4, %r5;
728         eor %r3, %r6;
729
730         /* load IV+2 (src[1]) to %r7:%r8. Might be unaligned. */
731         read_block_host(%r0, 8, %r7, %r8, %r5);
732         /* store IV+2 to iv[0] (aligned). */
733         stm %r2, {%r7, %r8};
734
735         /* store result to dst[0-3]. Might be unaligned. */
736         write_block2_host(%r1, %r4, %r3, %r10, %r9, %r5, %r6);
737
738         pop {%r4-%r11, %ip, %pc};
739 .ltorg
740 .size _gcry_blowfish_arm_cbc_dec,.-_gcry_blowfish_arm_cbc_dec;
741
742 #endif /*HAVE_COMPATIBLE_GCC_AMD64_PLATFORM_AS*/
743 #endif /*__ARM_ARCH >= 6*/