modes/asm/ghash-armv4.pl: improve interoperability with Android NDK.
[openssl.git] / crypto / modes / asm / ghash-armv4.pl
1 #! /usr/bin/env perl
2 # Copyright 2010-2016 The OpenSSL Project Authors. All Rights Reserved.
3 #
4 # Licensed under the OpenSSL license (the "License").  You may not use
5 # this file except in compliance with the License.  You can obtain a copy
6 # in the file LICENSE in the source distribution or at
7 # https://www.openssl.org/source/license.html
8
9 #
10 # ====================================================================
11 # Written by Andy Polyakov <appro@openssl.org> for the OpenSSL
12 # project. The module is, however, dual licensed under OpenSSL and
13 # CRYPTOGAMS licenses depending on where you obtain it. For further
14 # details see http://www.openssl.org/~appro/cryptogams/.
15 # ====================================================================
16 #
17 # April 2010
18 #
19 # The module implements "4-bit" GCM GHASH function and underlying
20 # single multiplication operation in GF(2^128). "4-bit" means that it
21 # uses 256 bytes per-key table [+32 bytes shared table]. There is no
22 # experimental performance data available yet. The only approximation
23 # that can be made at this point is based on code size. Inner loop is
24 # 32 instructions long and on single-issue core should execute in <40
25 # cycles. Having verified that gcc 3.4 didn't unroll corresponding
26 # loop, this assembler loop body was found to be ~3x smaller than
27 # compiler-generated one...
28 #
29 # July 2010
30 #
31 # Rescheduling for dual-issue pipeline resulted in 8.5% improvement on
32 # Cortex A8 core and ~25 cycles per processed byte (which was observed
33 # to be ~3 times faster than gcc-generated code:-)
34 #
35 # February 2011
36 #
37 # Profiler-assisted and platform-specific optimization resulted in 7%
38 # improvement on Cortex A8 core and ~23.5 cycles per byte.
39 #
40 # March 2011
41 #
42 # Add NEON implementation featuring polynomial multiplication, i.e. no
43 # lookup tables involved. On Cortex A8 it was measured to process one
44 # byte in 15 cycles or 55% faster than integer-only code.
45 #
46 # April 2014
47 #
48 # Switch to multiplication algorithm suggested in paper referred
49 # below and combine it with reduction algorithm from x86 module.
50 # Performance improvement over previous version varies from 65% on
51 # Snapdragon S4 to 110% on Cortex A9. In absolute terms Cortex A8
52 # processes one byte in 8.45 cycles, A9 - in 10.2, A15 - in 7.63,
53 # Snapdragon S4 - in 9.33.
54 #
55 # Câmara, D.; Gouvêa, C. P. L.; López, J. & Dahab, R.: Fast Software
56 # Polynomial Multiplication on ARM Processors using the NEON Engine.
57
58 # http://conradoplg.cryptoland.net/files/2010/12/mocrysen13.pdf
59
60 # ====================================================================
61 # Note about "528B" variant. In ARM case it makes lesser sense to
62 # implement it for following reasons:
63 #
64 # - performance improvement won't be anywhere near 50%, because 128-
65 #   bit shift operation is neatly fused with 128-bit xor here, and
66 #   "538B" variant would eliminate only 4-5 instructions out of 32
67 #   in the inner loop (meaning that estimated improvement is ~15%);
68 # - ARM-based systems are often embedded ones and extra memory
69 #   consumption might be unappreciated (for so little improvement);
70 #
71 # Byte order [in]dependence. =========================================
72 #
73 # Caller is expected to maintain specific *dword* order in Htable,
74 # namely with *least* significant dword of 128-bit value at *lower*
75 # address. This differs completely from C code and has everything to
76 # do with ldm instruction and order in which dwords are "consumed" by
77 # algorithm. *Byte* order within these dwords in turn is whatever
78 # *native* byte order on current platform. See gcm128.c for working
79 # example...
80
81 $flavour = shift;
82 if ($flavour=~/\w[\w\-]*\.\w+$/) { $output=$flavour; undef $flavour; }
83 else { while (($output=shift) && ($output!~/\w[\w\-]*\.\w+$/)) {} }
84
85 if ($flavour && $flavour ne "void") {
86     $0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1;
87     ( $xlate="${dir}arm-xlate.pl" and -f $xlate ) or
88     ( $xlate="${dir}../../perlasm/arm-xlate.pl" and -f $xlate) or
89     die "can't locate arm-xlate.pl";
90
91     open STDOUT,"| \"$^X\" $xlate $flavour $output";
92 } else {
93     open STDOUT,">$output";
94 }
95
96 $Xi="r0";       # argument block
97 $Htbl="r1";
98 $inp="r2";
99 $len="r3";
100
101 $Zll="r4";      # variables
102 $Zlh="r5";
103 $Zhl="r6";
104 $Zhh="r7";
105 $Tll="r8";
106 $Tlh="r9";
107 $Thl="r10";
108 $Thh="r11";
109 $nlo="r12";
110 ################# r13 is stack pointer
111 $nhi="r14";
112 ################# r15 is program counter
113
114 $rem_4bit=$inp; # used in gcm_gmult_4bit
115 $cnt=$len;
116
117 sub Zsmash() {
118   my $i=12;
119   my @args=@_;
120   for ($Zll,$Zlh,$Zhl,$Zhh) {
121     $code.=<<___;
122 #if __ARM_ARCH__>=7 && defined(__ARMEL__)
123         rev     $_,$_
124         str     $_,[$Xi,#$i]
125 #elif defined(__ARMEB__)
126         str     $_,[$Xi,#$i]
127 #else
128         mov     $Tlh,$_,lsr#8
129         strb    $_,[$Xi,#$i+3]
130         mov     $Thl,$_,lsr#16
131         strb    $Tlh,[$Xi,#$i+2]
132         mov     $Thh,$_,lsr#24
133         strb    $Thl,[$Xi,#$i+1]
134         strb    $Thh,[$Xi,#$i]
135 #endif
136 ___
137     $code.="\t".shift(@args)."\n";
138     $i-=4;
139   }
140 }
141
142 $code=<<___;
143 #include "arm_arch.h"
144
145 .text
146 #if defined(__thumb2__) || defined(__clang__)
147 .syntax unified
148 #endif
149 #if defined(__thumb2__)
150 .thumb
151 #else
152 .code   32
153 #endif
154
155 #ifdef  __clang__
156 #define ldrplb  ldrbpl
157 #define ldrneb  ldrbne
158 #endif
159
160 .type   rem_4bit,%object
161 .align  5
162 rem_4bit:
163 .short  0x0000,0x1C20,0x3840,0x2460
164 .short  0x7080,0x6CA0,0x48C0,0x54E0
165 .short  0xE100,0xFD20,0xD940,0xC560
166 .short  0x9180,0x8DA0,0xA9C0,0xB5E0
167 .size   rem_4bit,.-rem_4bit
168
169 .type   rem_4bit_get,%function
170 rem_4bit_get:
171 #if defined(__thumb2__)
172         adr     $rem_4bit,rem_4bit
173 #else
174         sub     $rem_4bit,pc,#8+32      @ &rem_4bit
175 #endif
176         b       .Lrem_4bit_got
177         nop
178         nop
179 .size   rem_4bit_get,.-rem_4bit_get
180
181 .global gcm_ghash_4bit
182 .type   gcm_ghash_4bit,%function
183 .align  4
184 gcm_ghash_4bit:
185 #if defined(__thumb2__)
186         adr     r12,rem_4bit
187 #else
188         sub     r12,pc,#8+48            @ &rem_4bit
189 #endif
190         add     $len,$inp,$len          @ $len to point at the end
191         stmdb   sp!,{r3-r11,lr}         @ save $len/end too
192
193         ldmia   r12,{r4-r11}            @ copy rem_4bit ...
194         stmdb   sp!,{r4-r11}            @ ... to stack
195
196         ldrb    $nlo,[$inp,#15]
197         ldrb    $nhi,[$Xi,#15]
198 .Louter:
199         eor     $nlo,$nlo,$nhi
200         and     $nhi,$nlo,#0xf0
201         and     $nlo,$nlo,#0x0f
202         mov     $cnt,#14
203
204         add     $Zhh,$Htbl,$nlo,lsl#4
205         ldmia   $Zhh,{$Zll-$Zhh}        @ load Htbl[nlo]
206         add     $Thh,$Htbl,$nhi
207         ldrb    $nlo,[$inp,#14]
208
209         and     $nhi,$Zll,#0xf          @ rem
210         ldmia   $Thh,{$Tll-$Thh}        @ load Htbl[nhi]
211         add     $nhi,$nhi,$nhi
212         eor     $Zll,$Tll,$Zll,lsr#4
213         ldrh    $Tll,[sp,$nhi]          @ rem_4bit[rem]
214         eor     $Zll,$Zll,$Zlh,lsl#28
215         ldrb    $nhi,[$Xi,#14]
216         eor     $Zlh,$Tlh,$Zlh,lsr#4
217         eor     $Zlh,$Zlh,$Zhl,lsl#28
218         eor     $Zhl,$Thl,$Zhl,lsr#4
219         eor     $Zhl,$Zhl,$Zhh,lsl#28
220         eor     $Zhh,$Thh,$Zhh,lsr#4
221         eor     $nlo,$nlo,$nhi
222         and     $nhi,$nlo,#0xf0
223         and     $nlo,$nlo,#0x0f
224         eor     $Zhh,$Zhh,$Tll,lsl#16
225
226 .Linner:
227         add     $Thh,$Htbl,$nlo,lsl#4
228         and     $nlo,$Zll,#0xf          @ rem
229         subs    $cnt,$cnt,#1
230         add     $nlo,$nlo,$nlo
231         ldmia   $Thh,{$Tll-$Thh}        @ load Htbl[nlo]
232         eor     $Zll,$Tll,$Zll,lsr#4
233         eor     $Zll,$Zll,$Zlh,lsl#28
234         eor     $Zlh,$Tlh,$Zlh,lsr#4
235         eor     $Zlh,$Zlh,$Zhl,lsl#28
236         ldrh    $Tll,[sp,$nlo]          @ rem_4bit[rem]
237         eor     $Zhl,$Thl,$Zhl,lsr#4
238 #ifdef  __thumb2__
239         it      pl
240 #endif
241         ldrplb  $nlo,[$inp,$cnt]
242         eor     $Zhl,$Zhl,$Zhh,lsl#28
243         eor     $Zhh,$Thh,$Zhh,lsr#4
244
245         add     $Thh,$Htbl,$nhi
246         and     $nhi,$Zll,#0xf          @ rem
247         eor     $Zhh,$Zhh,$Tll,lsl#16   @ ^= rem_4bit[rem]
248         add     $nhi,$nhi,$nhi
249         ldmia   $Thh,{$Tll-$Thh}        @ load Htbl[nhi]
250         eor     $Zll,$Tll,$Zll,lsr#4
251 #ifdef  __thumb2__
252         it      pl
253 #endif
254         ldrplb  $Tll,[$Xi,$cnt]
255         eor     $Zll,$Zll,$Zlh,lsl#28
256         eor     $Zlh,$Tlh,$Zlh,lsr#4
257         ldrh    $Tlh,[sp,$nhi]
258         eor     $Zlh,$Zlh,$Zhl,lsl#28
259         eor     $Zhl,$Thl,$Zhl,lsr#4
260         eor     $Zhl,$Zhl,$Zhh,lsl#28
261 #ifdef  __thumb2__
262         it      pl
263 #endif
264         eorpl   $nlo,$nlo,$Tll
265         eor     $Zhh,$Thh,$Zhh,lsr#4
266 #ifdef  __thumb2__
267         itt     pl
268 #endif
269         andpl   $nhi,$nlo,#0xf0
270         andpl   $nlo,$nlo,#0x0f
271         eor     $Zhh,$Zhh,$Tlh,lsl#16   @ ^= rem_4bit[rem]
272         bpl     .Linner
273
274         ldr     $len,[sp,#32]           @ re-load $len/end
275         add     $inp,$inp,#16
276         mov     $nhi,$Zll
277 ___
278         &Zsmash("cmp\t$inp,$len","\n".
279                                  "#ifdef __thumb2__\n".
280                                  "      it      ne\n".
281                                  "#endif\n".
282                                  "      ldrneb  $nlo,[$inp,#15]");
283 $code.=<<___;
284         bne     .Louter
285
286         add     sp,sp,#36
287 #if __ARM_ARCH__>=5
288         ldmia   sp!,{r4-r11,pc}
289 #else
290         ldmia   sp!,{r4-r11,lr}
291         tst     lr,#1
292         moveq   pc,lr                   @ be binary compatible with V4, yet
293         bx      lr                      @ interoperable with Thumb ISA:-)
294 #endif
295 .size   gcm_ghash_4bit,.-gcm_ghash_4bit
296
297 .global gcm_gmult_4bit
298 .type   gcm_gmult_4bit,%function
299 gcm_gmult_4bit:
300         stmdb   sp!,{r4-r11,lr}
301         ldrb    $nlo,[$Xi,#15]
302         b       rem_4bit_get
303 .Lrem_4bit_got:
304         and     $nhi,$nlo,#0xf0
305         and     $nlo,$nlo,#0x0f
306         mov     $cnt,#14
307
308         add     $Zhh,$Htbl,$nlo,lsl#4
309         ldmia   $Zhh,{$Zll-$Zhh}        @ load Htbl[nlo]
310         ldrb    $nlo,[$Xi,#14]
311
312         add     $Thh,$Htbl,$nhi
313         and     $nhi,$Zll,#0xf          @ rem
314         ldmia   $Thh,{$Tll-$Thh}        @ load Htbl[nhi]
315         add     $nhi,$nhi,$nhi
316         eor     $Zll,$Tll,$Zll,lsr#4
317         ldrh    $Tll,[$rem_4bit,$nhi]   @ rem_4bit[rem]
318         eor     $Zll,$Zll,$Zlh,lsl#28
319         eor     $Zlh,$Tlh,$Zlh,lsr#4
320         eor     $Zlh,$Zlh,$Zhl,lsl#28
321         eor     $Zhl,$Thl,$Zhl,lsr#4
322         eor     $Zhl,$Zhl,$Zhh,lsl#28
323         eor     $Zhh,$Thh,$Zhh,lsr#4
324         and     $nhi,$nlo,#0xf0
325         eor     $Zhh,$Zhh,$Tll,lsl#16
326         and     $nlo,$nlo,#0x0f
327
328 .Loop:
329         add     $Thh,$Htbl,$nlo,lsl#4
330         and     $nlo,$Zll,#0xf          @ rem
331         subs    $cnt,$cnt,#1
332         add     $nlo,$nlo,$nlo
333         ldmia   $Thh,{$Tll-$Thh}        @ load Htbl[nlo]
334         eor     $Zll,$Tll,$Zll,lsr#4
335         eor     $Zll,$Zll,$Zlh,lsl#28
336         eor     $Zlh,$Tlh,$Zlh,lsr#4
337         eor     $Zlh,$Zlh,$Zhl,lsl#28
338         ldrh    $Tll,[$rem_4bit,$nlo]   @ rem_4bit[rem]
339         eor     $Zhl,$Thl,$Zhl,lsr#4
340 #ifdef  __thumb2__
341         it      pl
342 #endif
343         ldrplb  $nlo,[$Xi,$cnt]
344         eor     $Zhl,$Zhl,$Zhh,lsl#28
345         eor     $Zhh,$Thh,$Zhh,lsr#4
346
347         add     $Thh,$Htbl,$nhi
348         and     $nhi,$Zll,#0xf          @ rem
349         eor     $Zhh,$Zhh,$Tll,lsl#16   @ ^= rem_4bit[rem]
350         add     $nhi,$nhi,$nhi
351         ldmia   $Thh,{$Tll-$Thh}        @ load Htbl[nhi]
352         eor     $Zll,$Tll,$Zll,lsr#4
353         eor     $Zll,$Zll,$Zlh,lsl#28
354         eor     $Zlh,$Tlh,$Zlh,lsr#4
355         ldrh    $Tll,[$rem_4bit,$nhi]   @ rem_4bit[rem]
356         eor     $Zlh,$Zlh,$Zhl,lsl#28
357         eor     $Zhl,$Thl,$Zhl,lsr#4
358         eor     $Zhl,$Zhl,$Zhh,lsl#28
359         eor     $Zhh,$Thh,$Zhh,lsr#4
360 #ifdef  __thumb2__
361         itt     pl
362 #endif
363         andpl   $nhi,$nlo,#0xf0
364         andpl   $nlo,$nlo,#0x0f
365         eor     $Zhh,$Zhh,$Tll,lsl#16   @ ^= rem_4bit[rem]
366         bpl     .Loop
367 ___
368         &Zsmash();
369 $code.=<<___;
370 #if __ARM_ARCH__>=5
371         ldmia   sp!,{r4-r11,pc}
372 #else
373         ldmia   sp!,{r4-r11,lr}
374         tst     lr,#1
375         moveq   pc,lr                   @ be binary compatible with V4, yet
376         bx      lr                      @ interoperable with Thumb ISA:-)
377 #endif
378 .size   gcm_gmult_4bit,.-gcm_gmult_4bit
379 ___
380 {
381 my ($Xl,$Xm,$Xh,$IN)=map("q$_",(0..3));
382 my ($t0,$t1,$t2,$t3)=map("q$_",(8..12));
383 my ($Hlo,$Hhi,$Hhl,$k48,$k32,$k16)=map("d$_",(26..31));
384
385 sub clmul64x64 {
386 my ($r,$a,$b)=@_;
387 $code.=<<___;
388         vext.8          $t0#lo, $a, $a, #1      @ A1
389         vmull.p8        $t0, $t0#lo, $b         @ F = A1*B
390         vext.8          $r#lo, $b, $b, #1       @ B1
391         vmull.p8        $r, $a, $r#lo           @ E = A*B1
392         vext.8          $t1#lo, $a, $a, #2      @ A2
393         vmull.p8        $t1, $t1#lo, $b         @ H = A2*B
394         vext.8          $t3#lo, $b, $b, #2      @ B2
395         vmull.p8        $t3, $a, $t3#lo         @ G = A*B2
396         vext.8          $t2#lo, $a, $a, #3      @ A3
397         veor            $t0, $t0, $r            @ L = E + F
398         vmull.p8        $t2, $t2#lo, $b         @ J = A3*B
399         vext.8          $r#lo, $b, $b, #3       @ B3
400         veor            $t1, $t1, $t3           @ M = G + H
401         vmull.p8        $r, $a, $r#lo           @ I = A*B3
402         veor            $t0#lo, $t0#lo, $t0#hi  @ t0 = (L) (P0 + P1) << 8
403         vand            $t0#hi, $t0#hi, $k48
404         vext.8          $t3#lo, $b, $b, #4      @ B4
405         veor            $t1#lo, $t1#lo, $t1#hi  @ t1 = (M) (P2 + P3) << 16
406         vand            $t1#hi, $t1#hi, $k32
407         vmull.p8        $t3, $a, $t3#lo         @ K = A*B4
408         veor            $t2, $t2, $r            @ N = I + J
409         veor            $t0#lo, $t0#lo, $t0#hi
410         veor            $t1#lo, $t1#lo, $t1#hi
411         veor            $t2#lo, $t2#lo, $t2#hi  @ t2 = (N) (P4 + P5) << 24
412         vand            $t2#hi, $t2#hi, $k16
413         vext.8          $t0, $t0, $t0, #15
414         veor            $t3#lo, $t3#lo, $t3#hi  @ t3 = (K) (P6 + P7) << 32
415         vmov.i64        $t3#hi, #0
416         vext.8          $t1, $t1, $t1, #14
417         veor            $t2#lo, $t2#lo, $t2#hi
418         vmull.p8        $r, $a, $b              @ D = A*B
419         vext.8          $t3, $t3, $t3, #12
420         vext.8          $t2, $t2, $t2, #13
421         veor            $t0, $t0, $t1
422         veor            $t2, $t2, $t3
423         veor            $r, $r, $t0
424         veor            $r, $r, $t2
425 ___
426 }
427
428 $code.=<<___;
429 #if __ARM_MAX_ARCH__>=7
430 .arch   armv7-a
431 .fpu    neon
432
433 .global gcm_init_neon
434 .type   gcm_init_neon,%function
435 .align  4
436 gcm_init_neon:
437         vld1.64         $IN#hi,[r1]!            @ load H
438         vmov.i8         $t0,#0xe1
439         vld1.64         $IN#lo,[r1]
440         vshl.i64        $t0#hi,#57
441         vshr.u64        $t0#lo,#63              @ t0=0xc2....01
442         vdup.8          $t1,$IN#hi[7]
443         vshr.u64        $Hlo,$IN#lo,#63
444         vshr.s8         $t1,#7                  @ broadcast carry bit
445         vshl.i64        $IN,$IN,#1
446         vand            $t0,$t0,$t1
447         vorr            $IN#hi,$Hlo             @ H<<<=1
448         veor            $IN,$IN,$t0             @ twisted H
449         vstmia          r0,{$IN}
450
451         ret                                     @ bx lr
452 .size   gcm_init_neon,.-gcm_init_neon
453
454 .global gcm_gmult_neon
455 .type   gcm_gmult_neon,%function
456 .align  4
457 gcm_gmult_neon:
458         vld1.64         $IN#hi,[$Xi]!           @ load Xi
459         vld1.64         $IN#lo,[$Xi]!
460         vmov.i64        $k48,#0x0000ffffffffffff
461         vldmia          $Htbl,{$Hlo-$Hhi}       @ load twisted H
462         vmov.i64        $k32,#0x00000000ffffffff
463 #ifdef __ARMEL__
464         vrev64.8        $IN,$IN
465 #endif
466         vmov.i64        $k16,#0x000000000000ffff
467         veor            $Hhl,$Hlo,$Hhi          @ Karatsuba pre-processing
468         mov             $len,#16
469         b               .Lgmult_neon
470 .size   gcm_gmult_neon,.-gcm_gmult_neon
471
472 .global gcm_ghash_neon
473 .type   gcm_ghash_neon,%function
474 .align  4
475 gcm_ghash_neon:
476         vld1.64         $Xl#hi,[$Xi]!           @ load Xi
477         vld1.64         $Xl#lo,[$Xi]!
478         vmov.i64        $k48,#0x0000ffffffffffff
479         vldmia          $Htbl,{$Hlo-$Hhi}       @ load twisted H
480         vmov.i64        $k32,#0x00000000ffffffff
481 #ifdef __ARMEL__
482         vrev64.8        $Xl,$Xl
483 #endif
484         vmov.i64        $k16,#0x000000000000ffff
485         veor            $Hhl,$Hlo,$Hhi          @ Karatsuba pre-processing
486
487 .Loop_neon:
488         vld1.64         $IN#hi,[$inp]!          @ load inp
489         vld1.64         $IN#lo,[$inp]!
490 #ifdef __ARMEL__
491         vrev64.8        $IN,$IN
492 #endif
493         veor            $IN,$Xl                 @ inp^=Xi
494 .Lgmult_neon:
495 ___
496         &clmul64x64     ($Xl,$Hlo,"$IN#lo");    # H.lo·Xi.lo
497 $code.=<<___;
498         veor            $IN#lo,$IN#lo,$IN#hi    @ Karatsuba pre-processing
499 ___
500         &clmul64x64     ($Xm,$Hhl,"$IN#lo");    # (H.lo+H.hi)·(Xi.lo+Xi.hi)
501         &clmul64x64     ($Xh,$Hhi,"$IN#hi");    # H.hi·Xi.hi
502 $code.=<<___;
503         veor            $Xm,$Xm,$Xl             @ Karatsuba post-processing
504         veor            $Xm,$Xm,$Xh
505         veor            $Xl#hi,$Xl#hi,$Xm#lo
506         veor            $Xh#lo,$Xh#lo,$Xm#hi    @ Xh|Xl - 256-bit result
507
508         @ equivalent of reduction_avx from ghash-x86_64.pl
509         vshl.i64        $t1,$Xl,#57             @ 1st phase
510         vshl.i64        $t2,$Xl,#62
511         veor            $t2,$t2,$t1             @
512         vshl.i64        $t1,$Xl,#63
513         veor            $t2, $t2, $t1           @
514         veor            $Xl#hi,$Xl#hi,$t2#lo    @
515         veor            $Xh#lo,$Xh#lo,$t2#hi
516
517         vshr.u64        $t2,$Xl,#1              @ 2nd phase
518         veor            $Xh,$Xh,$Xl
519         veor            $Xl,$Xl,$t2             @
520         vshr.u64        $t2,$t2,#6
521         vshr.u64        $Xl,$Xl,#1              @
522         veor            $Xl,$Xl,$Xh             @
523         veor            $Xl,$Xl,$t2             @
524
525         subs            $len,#16
526         bne             .Loop_neon
527
528 #ifdef __ARMEL__
529         vrev64.8        $Xl,$Xl
530 #endif
531         sub             $Xi,#16 
532         vst1.64         $Xl#hi,[$Xi]!           @ write out Xi
533         vst1.64         $Xl#lo,[$Xi]
534
535         ret                                     @ bx lr
536 .size   gcm_ghash_neon,.-gcm_ghash_neon
537 #endif
538 ___
539 }
540 $code.=<<___;
541 .asciz  "GHASH for ARMv4/NEON, CRYPTOGAMS by <appro\@openssl.org>"
542 .align  2
543 ___
544
545 foreach (split("\n",$code)) {
546         s/\`([^\`]*)\`/eval $1/geo;
547
548         s/\bq([0-9]+)#(lo|hi)/sprintf "d%d",2*$1+($2 eq "hi")/geo       or
549         s/\bret\b/bx    lr/go           or
550         s/\bbx\s+lr\b/.word\t0xe12fff1e/go;    # make it possible to compile with -march=armv4
551
552         print $_,"\n";
553 }
554 close STDOUT; # enforce flush