bn/asm/armv8-mont.pl: boost performance.
[openssl.git] / crypto / ec / asm / ecp_nistz256-armv8.pl
1 #!/usr/bin/env perl
2
3 # ====================================================================
4 # Written by Andy Polyakov <appro@openssl.org> for the OpenSSL
5 # project. The module is, however, dual licensed under OpenSSL and
6 # CRYPTOGAMS licenses depending on where you obtain it. For further
7 # details see http://www.openssl.org/~appro/cryptogams/.
8 # ====================================================================
9 #
10 # ECP_NISTZ256 module for ARMv8.
11 #
12 # February 2015.
13 #
14 # Original ECP_NISTZ256 submission targeting x86_64 is detailed in
15 # http://eprint.iacr.org/2013/816.
16 #
17 #                       with/without -DECP_NISTZ256_ASM
18 # Apple A7              +120-360%
19 # Cortex-A53            +120-400%
20 # Cortex-A57            +120-350%
21 # X-Gene                +200-330%
22 # Denver                +140-400%
23 #
24 # Ranges denote minimum and maximum improvement coefficients depending
25 # on benchmark. Lower coefficients are for ECDSA sign, server-side
26 # operation. Keep in mind that +400% means 5x improvement.
27
28 $flavour = shift;
29 while (($output=shift) && ($output!~/^\w[\w\-]*\.\w+$/)) {}
30
31 $0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1;
32 ( $xlate="${dir}arm-xlate.pl" and -f $xlate ) or
33 ( $xlate="${dir}../../perlasm/arm-xlate.pl" and -f $xlate) or
34 die "can't locate arm-xlate.pl";
35
36 open OUT,"| \"$^X\" $xlate $flavour $output";
37 *STDOUT=*OUT;
38
39 {
40 my ($rp,$ap,$bp,$bi,$a0,$a1,$a2,$a3,$t0,$t1,$t2,$t3,$poly1,$poly3,
41     $acc0,$acc1,$acc2,$acc3,$acc4,$acc5) =
42     map("x$_",(0..17,19,20));
43
44 my ($acc6,$acc7)=($ap,$bp);     # used in __ecp_nistz256_sqr_mont
45
46 $code.=<<___;
47 #include "arm_arch.h"
48
49 .text
50 ___
51 ########################################################################
52 # Convert ecp_nistz256_table.c to layout expected by ecp_nistz_gather_w7
53 #
54 $0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1;
55 open TABLE,"<ecp_nistz256_table.c"              or
56 open TABLE,"<${dir}../ecp_nistz256_table.c"     or
57 die "failed to open ecp_nistz256_table.c:",$!;
58
59 use integer;
60
61 foreach(<TABLE>) {
62         s/TOBN\(\s*(0x[0-9a-f]+),\s*(0x[0-9a-f]+)\s*\)/push @arr,hex($2),hex($1)/geo;
63 }
64 close TABLE;
65
66 # See ecp_nistz256_table.c for explanation for why it's 64*16*37.
67 # 64*16*37-1 is because $#arr returns last valid index or @arr, not
68 # amount of elements.
69 die "insane number of elements" if ($#arr != 64*16*37-1);
70
71 $code.=<<___;
72 .globl  ecp_nistz256_precomputed
73 .type   ecp_nistz256_precomputed,%object
74 .align  12
75 ecp_nistz256_precomputed:
76 ___
77 ########################################################################
78 # this conversion smashes P256_POINT_AFFINE by individual bytes with
79 # 64 byte interval, similar to
80 #       1111222233334444
81 #       1234123412341234
82 for(1..37) {
83         @tbl = splice(@arr,0,64*16);
84         for($i=0;$i<64;$i++) {
85                 undef @line;
86                 for($j=0;$j<64;$j++) {
87                         push @line,(@tbl[$j*16+$i/4]>>(($i%4)*8))&0xff;
88                 }
89                 $code.=".byte\t";
90                 $code.=join(',',map { sprintf "0x%02x",$_} @line);
91                 $code.="\n";
92         }
93 }
94 $code.=<<___;
95 .size   ecp_nistz256_precomputed,.-ecp_nistz256_precomputed
96 .align  5
97 .Lpoly:
98 .quad   0xffffffffffffffff,0x00000000ffffffff,0x0000000000000000,0xffffffff00000001
99 .LRR:   // 2^512 mod P precomputed for NIST P256 polynomial
100 .quad   0x0000000000000003,0xfffffffbffffffff,0xfffffffffffffffe,0x00000004fffffffd
101 .Lone_mont:
102 .quad   0x0000000000000001,0xffffffff00000000,0xffffffffffffffff,0x00000000fffffffe
103 .Lone:
104 .quad   1,0,0,0
105 .asciz  "ECP_NISTZ256 for ARMv8, CRYPTOGAMS by <appro\@openssl.org>"
106
107 // void ecp_nistz256_to_mont(BN_ULONG x0[4],const BN_ULONG x1[4]);
108 .globl  ecp_nistz256_to_mont
109 .type   ecp_nistz256_to_mont,%function
110 .align  6
111 ecp_nistz256_to_mont:
112         stp     x29,x30,[sp,#-32]!
113         add     x29,sp,#0
114         stp     x19,x20,[sp,#16]
115
116         ldr     $bi,.LRR                // bp[0]
117         ldp     $a0,$a1,[$ap]
118         ldp     $a2,$a3,[$ap,#16]
119         ldr     $poly1,.Lpoly+8
120         ldr     $poly3,.Lpoly+24
121         adr     $bp,.LRR                // &bp[0]
122
123         bl      __ecp_nistz256_mul_mont
124
125         ldp     x19,x20,[sp,#16]
126         ldp     x29,x30,[sp],#32
127         ret
128 .size   ecp_nistz256_to_mont,.-ecp_nistz256_to_mont
129
130 // void ecp_nistz256_from_mont(BN_ULONG x0[4],const BN_ULONG x1[4]);
131 .globl  ecp_nistz256_from_mont
132 .type   ecp_nistz256_from_mont,%function
133 .align  4
134 ecp_nistz256_from_mont:
135         stp     x29,x30,[sp,#-32]!
136         add     x29,sp,#0
137         stp     x19,x20,[sp,#16]
138
139         mov     $bi,#1                  // bp[0]
140         ldp     $a0,$a1,[$ap]
141         ldp     $a2,$a3,[$ap,#16]
142         ldr     $poly1,.Lpoly+8
143         ldr     $poly3,.Lpoly+24
144         adr     $bp,.Lone               // &bp[0]
145
146         bl      __ecp_nistz256_mul_mont
147
148         ldp     x19,x20,[sp,#16]
149         ldp     x29,x30,[sp],#32
150         ret
151 .size   ecp_nistz256_from_mont,.-ecp_nistz256_from_mont
152
153 // void ecp_nistz256_mul_mont(BN_ULONG x0[4],const BN_ULONG x1[4],
154 //                                           const BN_ULONG x2[4]);
155 .globl  ecp_nistz256_mul_mont
156 .type   ecp_nistz256_mul_mont,%function
157 .align  4
158 ecp_nistz256_mul_mont:
159         stp     x29,x30,[sp,#-32]!
160         add     x29,sp,#0
161         stp     x19,x20,[sp,#16]
162
163         ldr     $bi,[$bp]               // bp[0]
164         ldp     $a0,$a1,[$ap]
165         ldp     $a2,$a3,[$ap,#16]
166         ldr     $poly1,.Lpoly+8
167         ldr     $poly3,.Lpoly+24
168
169         bl      __ecp_nistz256_mul_mont
170
171         ldp     x19,x20,[sp,#16]
172         ldp     x29,x30,[sp],#32
173         ret
174 .size   ecp_nistz256_mul_mont,.-ecp_nistz256_mul_mont
175
176 // void ecp_nistz256_sqr_mont(BN_ULONG x0[4],const BN_ULONG x1[4]);
177 .globl  ecp_nistz256_sqr_mont
178 .type   ecp_nistz256_sqr_mont,%function
179 .align  4
180 ecp_nistz256_sqr_mont:
181         stp     x29,x30,[sp,#-32]!
182         add     x29,sp,#0
183         stp     x19,x20,[sp,#16]
184
185         ldp     $a0,$a1,[$ap]
186         ldp     $a2,$a3,[$ap,#16]
187         ldr     $poly1,.Lpoly+8
188         ldr     $poly3,.Lpoly+24
189
190         bl      __ecp_nistz256_sqr_mont
191
192         ldp     x19,x20,[sp,#16]
193         ldp     x29,x30,[sp],#32
194         ret
195 .size   ecp_nistz256_sqr_mont,.-ecp_nistz256_sqr_mont
196
197 // void ecp_nistz256_add(BN_ULONG x0[4],const BN_ULONG x1[4],
198 //                                      const BN_ULONG x2[4]);
199 .globl  ecp_nistz256_add
200 .type   ecp_nistz256_add,%function
201 .align  4
202 ecp_nistz256_add:
203         stp     x29,x30,[sp,#-16]!
204         add     x29,sp,#0
205
206         ldp     $acc0,$acc1,[$ap]
207         ldp     $t0,$t1,[$bp]
208         ldp     $acc2,$acc3,[$ap,#16]
209         ldp     $t2,$t3,[$bp,#16]
210         ldr     $poly1,.Lpoly+8
211         ldr     $poly3,.Lpoly+24
212
213         bl      __ecp_nistz256_add
214
215         ldp     x29,x30,[sp],#16
216         ret
217 .size   ecp_nistz256_add,.-ecp_nistz256_add
218
219 // void ecp_nistz256_div_by_2(BN_ULONG x0[4],const BN_ULONG x1[4]);
220 .globl  ecp_nistz256_div_by_2
221 .type   ecp_nistz256_div_by_2,%function
222 .align  4
223 ecp_nistz256_div_by_2:
224         stp     x29,x30,[sp,#-16]!
225         add     x29,sp,#0
226
227         ldp     $acc0,$acc1,[$ap]
228         ldp     $acc2,$acc3,[$ap,#16]
229         ldr     $poly1,.Lpoly+8
230         ldr     $poly3,.Lpoly+24
231
232         bl      __ecp_nistz256_div_by_2
233
234         ldp     x29,x30,[sp],#16
235         ret
236 .size   ecp_nistz256_div_by_2,.-ecp_nistz256_div_by_2
237
238 // void ecp_nistz256_mul_by_2(BN_ULONG x0[4],const BN_ULONG x1[4]);
239 .globl  ecp_nistz256_mul_by_2
240 .type   ecp_nistz256_mul_by_2,%function
241 .align  4
242 ecp_nistz256_mul_by_2:
243         stp     x29,x30,[sp,#-16]!
244         add     x29,sp,#0
245
246         ldp     $acc0,$acc1,[$ap]
247         ldp     $acc2,$acc3,[$ap,#16]
248         ldr     $poly1,.Lpoly+8
249         ldr     $poly3,.Lpoly+24
250         mov     $t0,$acc0
251         mov     $t1,$acc1
252         mov     $t2,$acc2
253         mov     $t3,$acc3
254
255         bl      __ecp_nistz256_add      // ret = a+a    // 2*a
256
257         ldp     x29,x30,[sp],#16
258         ret
259 .size   ecp_nistz256_mul_by_2,.-ecp_nistz256_mul_by_2
260
261 // void ecp_nistz256_mul_by_3(BN_ULONG x0[4],const BN_ULONG x1[4]);
262 .globl  ecp_nistz256_mul_by_3
263 .type   ecp_nistz256_mul_by_3,%function
264 .align  4
265 ecp_nistz256_mul_by_3:
266         stp     x29,x30,[sp,#-16]!
267         add     x29,sp,#0
268
269         ldp     $acc0,$acc1,[$ap]
270         ldp     $acc2,$acc3,[$ap,#16]
271         ldr     $poly1,.Lpoly+8
272         ldr     $poly3,.Lpoly+24
273         mov     $t0,$acc0
274         mov     $t1,$acc1
275         mov     $t2,$acc2
276         mov     $t3,$acc3
277         mov     $a0,$acc0
278         mov     $a1,$acc1
279         mov     $a2,$acc2
280         mov     $a3,$acc3
281
282         bl      __ecp_nistz256_add      // ret = a+a    // 2*a
283
284         mov     $t0,$a0
285         mov     $t1,$a1
286         mov     $t2,$a2
287         mov     $t3,$a3
288
289         bl      __ecp_nistz256_add      // ret += a     // 2*a+a=3*a
290
291         ldp     x29,x30,[sp],#16
292         ret
293 .size   ecp_nistz256_mul_by_3,.-ecp_nistz256_mul_by_3
294
295 // void ecp_nistz256_sub(BN_ULONG x0[4],const BN_ULONG x1[4],
296 //                                      const BN_ULONG x2[4]);
297 .globl  ecp_nistz256_sub
298 .type   ecp_nistz256_sub,%function
299 .align  4
300 ecp_nistz256_sub:
301         stp     x29,x30,[sp,#-16]!
302         add     x29,sp,#0
303
304         ldp     $acc0,$acc1,[$ap]
305         ldp     $acc2,$acc3,[$ap,#16]
306         ldr     $poly1,.Lpoly+8
307         ldr     $poly3,.Lpoly+24
308
309         bl      __ecp_nistz256_sub_from
310
311         ldp     x29,x30,[sp],#16
312         ret
313 .size   ecp_nistz256_sub,.-ecp_nistz256_sub
314
315 // void ecp_nistz256_neg(BN_ULONG x0[4],const BN_ULONG x1[4]);
316 .globl  ecp_nistz256_neg
317 .type   ecp_nistz256_neg,%function
318 .align  4
319 ecp_nistz256_neg:
320         stp     x29,x30,[sp,#-16]!
321         add     x29,sp,#0
322
323         mov     $bp,$ap
324         mov     $acc0,xzr               // a = 0
325         mov     $acc1,xzr
326         mov     $acc2,xzr
327         mov     $acc3,xzr
328         ldr     $poly1,.Lpoly+8
329         ldr     $poly3,.Lpoly+24
330
331         bl      __ecp_nistz256_sub_from
332
333         ldp     x29,x30,[sp],#16
334         ret
335 .size   ecp_nistz256_neg,.-ecp_nistz256_neg
336
337 // note that __ecp_nistz256_mul_mont expects a[0-3] input pre-loaded
338 // to $a0-$a3 and b[0] - to $bi
339 .type   __ecp_nistz256_mul_mont,%function
340 .align  4
341 __ecp_nistz256_mul_mont:
342         mul     $acc0,$a0,$bi           // a[0]*b[0]
343         umulh   $t0,$a0,$bi
344
345         mul     $acc1,$a1,$bi           // a[1]*b[0]
346         umulh   $t1,$a1,$bi
347
348         mul     $acc2,$a2,$bi           // a[2]*b[0]
349         umulh   $t2,$a2,$bi
350
351         mul     $acc3,$a3,$bi           // a[3]*b[0]
352         umulh   $t3,$a3,$bi
353         ldr     $bi,[$bp,#8]            // b[1]
354
355         adds    $acc1,$acc1,$t0         // accumulate high parts of multiplication
356          lsl    $t0,$acc0,#32
357         adcs    $acc2,$acc2,$t1
358          lsr    $t1,$acc0,#32
359         adcs    $acc3,$acc3,$t2
360         adc     $acc4,xzr,$t3
361         mov     $acc5,xzr
362 ___
363 for($i=1;$i<4;$i++) {
364         # Reduction iteration is normally performed by accumulating
365         # result of multiplication of modulus by "magic" digit [and
366         # omitting least significant word, which is guaranteed to
367         # be 0], but thanks to special form of modulus and "magic"
368         # digit being equal to least significant word, it can be
369         # performed with additions and subtractions alone. Indeed:
370         #
371         #            ffff0001.00000000.0000ffff.ffffffff
372         # *                                     abcdefgh
373         # + xxxxxxxx.xxxxxxxx.xxxxxxxx.xxxxxxxx.abcdefgh
374         #
375         # Now observing that ff..ff*x = (2^n-1)*x = 2^n*x-x, we
376         # rewrite above as:
377         #
378         #   xxxxxxxx.xxxxxxxx.xxxxxxxx.xxxxxxxx.abcdefgh
379         # + abcdefgh.abcdefgh.0000abcd.efgh0000.00000000
380         # - 0000abcd.efgh0000.00000000.00000000.abcdefgh
381         #
382         # or marking redundant operations:
383         #
384         #   xxxxxxxx.xxxxxxxx.xxxxxxxx.xxxxxxxx.--------
385         # + abcdefgh.abcdefgh.0000abcd.efgh0000.--------
386         # - 0000abcd.efgh0000.--------.--------.--------
387
388 $code.=<<___;
389         subs    $t2,$acc0,$t0           // "*0xffff0001"
390         sbc     $t3,$acc0,$t1
391         adds    $acc0,$acc1,$t0         // +=acc[0]<<96 and omit acc[0]
392          mul    $t0,$a0,$bi             // lo(a[0]*b[i])
393         adcs    $acc1,$acc2,$t1
394          mul    $t1,$a1,$bi             // lo(a[1]*b[i])
395         adcs    $acc2,$acc3,$t2         // +=acc[0]*0xffff0001
396          mul    $t2,$a2,$bi             // lo(a[2]*b[i])
397         adcs    $acc3,$acc4,$t3
398          mul    $t3,$a3,$bi             // lo(a[3]*b[i])
399         adc     $acc4,$acc5,xzr
400
401         adds    $acc0,$acc0,$t0         // accumulate low parts of multiplication
402          umulh  $t0,$a0,$bi             // hi(a[0]*b[i])
403         adcs    $acc1,$acc1,$t1
404          umulh  $t1,$a1,$bi             // hi(a[1]*b[i])
405         adcs    $acc2,$acc2,$t2
406          umulh  $t2,$a2,$bi             // hi(a[2]*b[i])
407         adcs    $acc3,$acc3,$t3
408          umulh  $t3,$a3,$bi             // hi(a[3]*b[i])
409         adc     $acc4,$acc4,xzr
410 ___
411 $code.=<<___    if ($i<3);
412         ldr     $bi,[$bp,#8*($i+1)]     // b[$i+1]
413 ___
414 $code.=<<___;
415         adds    $acc1,$acc1,$t0         // accumulate high parts of multiplication
416          lsl    $t0,$acc0,#32
417         adcs    $acc2,$acc2,$t1
418          lsr    $t1,$acc0,#32
419         adcs    $acc3,$acc3,$t2
420         adcs    $acc4,$acc4,$t3
421         adc     $acc5,xzr,xzr
422 ___
423 }
424 $code.=<<___;
425         // last reduction
426         subs    $t2,$acc0,$t0           // "*0xffff0001"
427         sbc     $t3,$acc0,$t1
428         adds    $acc0,$acc1,$t0         // +=acc[0]<<96 and omit acc[0]
429         adcs    $acc1,$acc2,$t1
430         adcs    $acc2,$acc3,$t2         // +=acc[0]*0xffff0001
431         adcs    $acc3,$acc4,$t3
432         adc     $acc4,$acc5,xzr
433
434         adds    $t0,$acc0,#1            // subs $t0,$acc0,#-1 // tmp = ret-modulus
435         sbcs    $t1,$acc1,$poly1
436         sbcs    $t2,$acc2,xzr
437         sbcs    $t3,$acc3,$poly3
438         sbcs    xzr,$acc4,xzr           // did it borrow?
439
440         csel    $acc0,$acc0,$t0,lo      // ret = borrow ? ret : ret-modulus
441         csel    $acc1,$acc1,$t1,lo
442         csel    $acc2,$acc2,$t2,lo
443         stp     $acc0,$acc1,[$rp]
444         csel    $acc3,$acc3,$t3,lo
445         stp     $acc2,$acc3,[$rp,#16]
446
447         ret
448 .size   __ecp_nistz256_mul_mont,.-__ecp_nistz256_mul_mont
449
450 // note that __ecp_nistz256_sqr_mont expects a[0-3] input pre-loaded
451 // to $a0-$a3
452 .type   __ecp_nistz256_sqr_mont,%function
453 .align  4
454 __ecp_nistz256_sqr_mont:
455         //  |  |  |  |  |  |a1*a0|  |
456         //  |  |  |  |  |a2*a0|  |  |
457         //  |  |a3*a2|a3*a0|  |  |  |
458         //  |  |  |  |a2*a1|  |  |  |
459         //  |  |  |a3*a1|  |  |  |  |
460         // *|  |  |  |  |  |  |  | 2|
461         // +|a3*a3|a2*a2|a1*a1|a0*a0|
462         //  |--+--+--+--+--+--+--+--|
463         //  |A7|A6|A5|A4|A3|A2|A1|A0|, where Ax is $accx, i.e. follow $accx
464         //
465         //  "can't overflow" below mark carrying into high part of
466         //  multiplication result, which can't overflow, because it
467         //  can never be all ones.
468
469         mul     $acc1,$a1,$a0           // a[1]*a[0]
470         umulh   $t1,$a1,$a0
471         mul     $acc2,$a2,$a0           // a[2]*a[0]
472         umulh   $t2,$a2,$a0
473         mul     $acc3,$a3,$a0           // a[3]*a[0]
474         umulh   $acc4,$a3,$a0
475
476         adds    $acc2,$acc2,$t1         // accumulate high parts of multiplication
477          mul    $t0,$a2,$a1             // a[2]*a[1]
478          umulh  $t1,$a2,$a1
479         adcs    $acc3,$acc3,$t2
480          mul    $t2,$a3,$a1             // a[3]*a[1]
481          umulh  $t3,$a3,$a1
482         adc     $acc4,$acc4,xzr         // can't overflow
483
484         mul     $acc5,$a3,$a2           // a[3]*a[2]
485         umulh   $acc6,$a3,$a2
486
487         adds    $t1,$t1,$t2             // accumulate high parts of multiplication
488          mul    $acc0,$a0,$a0           // a[0]*a[0]
489         adc     $t2,$t3,xzr             // can't overflow
490
491         adds    $acc3,$acc3,$t0         // accumulate low parts of multiplication
492          umulh  $a0,$a0,$a0
493         adcs    $acc4,$acc4,$t1
494          mul    $t1,$a1,$a1             // a[1]*a[1]
495         adcs    $acc5,$acc5,$t2
496          umulh  $a1,$a1,$a1
497         adc     $acc6,$acc6,xzr         // can't overflow
498
499         adds    $acc1,$acc1,$acc1       // acc[1-6]*=2
500          mul    $t2,$a2,$a2             // a[2]*a[2]
501         adcs    $acc2,$acc2,$acc2
502          umulh  $a2,$a2,$a2
503         adcs    $acc3,$acc3,$acc3
504          mul    $t3,$a3,$a3             // a[3]*a[3]
505         adcs    $acc4,$acc4,$acc4
506          umulh  $a3,$a3,$a3
507         adcs    $acc5,$acc5,$acc5
508         adcs    $acc6,$acc6,$acc6
509         adc     $acc7,xzr,xzr
510
511         adds    $acc1,$acc1,$a0         // +a[i]*a[i]
512         adcs    $acc2,$acc2,$t1
513         adcs    $acc3,$acc3,$a1
514         adcs    $acc4,$acc4,$t2
515         adcs    $acc5,$acc5,$a2
516          lsl    $t0,$acc0,#32
517         adcs    $acc6,$acc6,$t3
518          lsr    $t1,$acc0,#32
519         adc     $acc7,$acc7,$a3
520 ___
521 for($i=0;$i<3;$i++) {                   # reductions, see commentary in
522                                         # multiplication for details
523 $code.=<<___;
524         subs    $t2,$acc0,$t0           // "*0xffff0001"
525         sbc     $t3,$acc0,$t1
526         adds    $acc0,$acc1,$t0         // +=acc[0]<<96 and omit acc[0]
527         adcs    $acc1,$acc2,$t1
528          lsl    $t0,$acc0,#32
529         adcs    $acc2,$acc3,$t2         // +=acc[0]*0xffff0001
530          lsr    $t1,$acc0,#32
531         adc     $acc3,$t3,xzr           // can't overflow
532 ___
533 }
534 $code.=<<___;
535         subs    $t2,$acc0,$t0           // "*0xffff0001"
536         sbc     $t3,$acc0,$t1
537         adds    $acc0,$acc1,$t0         // +=acc[0]<<96 and omit acc[0]
538         adcs    $acc1,$acc2,$t1
539         adcs    $acc2,$acc3,$t2         // +=acc[0]*0xffff0001
540         adc     $acc3,$t3,xzr           // can't overflow
541
542         adds    $acc0,$acc0,$acc4       // accumulate upper half
543         adcs    $acc1,$acc1,$acc5
544         adcs    $acc2,$acc2,$acc6
545         adcs    $acc3,$acc3,$acc7
546         adc     $acc4,xzr,xzr
547
548         adds    $t0,$acc0,#1            // subs $t0,$acc0,#-1 // tmp = ret-modulus
549         sbcs    $t1,$acc1,$poly1
550         sbcs    $t2,$acc2,xzr
551         sbcs    $t3,$acc3,$poly3
552         sbcs    xzr,$acc4,xzr           // did it borrow?
553
554         csel    $acc0,$acc0,$t0,lo      // ret = borrow ? ret : ret-modulus
555         csel    $acc1,$acc1,$t1,lo
556         csel    $acc2,$acc2,$t2,lo
557         stp     $acc0,$acc1,[$rp]
558         csel    $acc3,$acc3,$t3,lo
559         stp     $acc2,$acc3,[$rp,#16]
560
561         ret
562 .size   __ecp_nistz256_sqr_mont,.-__ecp_nistz256_sqr_mont
563
564 // Note that __ecp_nistz256_add expects both input vectors pre-loaded to
565 // $a0-$a3 and $t0-$t3. This is done because it's used in multiple
566 // contexts, e.g. in multiplication by 2 and 3...
567 .type   __ecp_nistz256_add,%function
568 .align  4
569 __ecp_nistz256_add:
570         adds    $acc0,$acc0,$t0         // ret = a+b
571         adcs    $acc1,$acc1,$t1
572         adcs    $acc2,$acc2,$t2
573         adcs    $acc3,$acc3,$t3
574         adc     $ap,xzr,xzr             // zap $ap
575
576         adds    $t0,$acc0,#1            // subs $t0,$a0,#-1 // tmp = ret-modulus
577         sbcs    $t1,$acc1,$poly1
578         sbcs    $t2,$acc2,xzr
579         sbc     $t3,$acc3,$poly3
580         cmp     $ap,xzr                 // did addition carry?
581
582         csel    $acc0,$acc0,$t0,eq      // ret = carry ? ret-modulus : ret
583         csel    $acc1,$acc1,$t1,eq
584         csel    $acc2,$acc2,$t2,eq
585         stp     $acc0,$acc1,[$rp]
586         csel    $acc3,$acc3,$t3,eq
587         stp     $acc2,$acc3,[$rp,#16]
588
589         ret
590 .size   __ecp_nistz256_add,.-__ecp_nistz256_add
591
592 .type   __ecp_nistz256_sub_from,%function
593 .align  4
594 __ecp_nistz256_sub_from:
595         ldp     $t0,$t1,[$bp]
596         ldp     $t2,$t3,[$bp,#16]
597         subs    $acc0,$acc0,$t0         // ret = a-b
598         sbcs    $acc1,$acc1,$t1
599         sbcs    $acc2,$acc2,$t2
600         sbcs    $acc3,$acc3,$t3
601         sbc     $ap,xzr,xzr             // zap $ap
602
603         subs    $t0,$acc0,#1            // adds $t0,$a0,#-1 // tmp = ret+modulus
604         adcs    $t1,$acc1,$poly1
605         adcs    $t2,$acc2,xzr
606         adc     $t3,$acc3,$poly3
607         cmp     $ap,xzr                 // did subtraction borrow?
608
609         csel    $acc0,$acc0,$t0,eq      // ret = borrow ? ret+modulus : ret
610         csel    $acc1,$acc1,$t1,eq
611         csel    $acc2,$acc2,$t2,eq
612         stp     $acc0,$acc1,[$rp]
613         csel    $acc3,$acc3,$t3,eq
614         stp     $acc2,$acc3,[$rp,#16]
615
616         ret
617 .size   __ecp_nistz256_sub_from,.-__ecp_nistz256_sub_from
618
619 .type   __ecp_nistz256_sub_morf,%function
620 .align  4
621 __ecp_nistz256_sub_morf:
622         ldp     $t0,$t1,[$bp]
623         ldp     $t2,$t3,[$bp,#16]
624         subs    $acc0,$t0,$acc0         // ret = b-a
625         sbcs    $acc1,$t1,$acc1
626         sbcs    $acc2,$t2,$acc2
627         sbcs    $acc3,$t3,$acc3
628         sbc     $ap,xzr,xzr             // zap $ap
629
630         subs    $t0,$acc0,#1            // adds $t0,$a0,#-1 // tmp = ret+modulus
631         adcs    $t1,$acc1,$poly1
632         adcs    $t2,$acc2,xzr
633         adc     $t3,$acc3,$poly3
634         cmp     $ap,xzr                 // did subtraction borrow?
635
636         csel    $acc0,$acc0,$t0,eq      // ret = borrow ? ret+modulus : ret
637         csel    $acc1,$acc1,$t1,eq
638         csel    $acc2,$acc2,$t2,eq
639         stp     $acc0,$acc1,[$rp]
640         csel    $acc3,$acc3,$t3,eq
641         stp     $acc2,$acc3,[$rp,#16]
642
643         ret
644 .size   __ecp_nistz256_sub_morf,.-__ecp_nistz256_sub_morf
645
646 .type   __ecp_nistz256_div_by_2,%function
647 .align  4
648 __ecp_nistz256_div_by_2:
649         subs    $t0,$acc0,#1            // adds $t0,$a0,#-1 // tmp = a+modulus
650         adcs    $t1,$acc1,$poly1
651         adcs    $t2,$acc2,xzr
652         adcs    $t3,$acc3,$poly3
653         adc     $ap,xzr,xzr             // zap $ap
654         tst     $acc0,#1                // is a even?
655
656         csel    $acc0,$acc0,$t0,eq      // ret = even ? a : a+modulus 
657         csel    $acc1,$acc1,$t1,eq
658         csel    $acc2,$acc2,$t2,eq
659         csel    $acc3,$acc3,$t3,eq
660         csel    $ap,xzr,$ap,eq
661
662         lsr     $acc0,$acc0,#1          // ret >>= 1
663         orr     $acc0,$acc0,$acc1,lsl#63
664         lsr     $acc1,$acc1,#1
665         orr     $acc1,$acc1,$acc2,lsl#63
666         lsr     $acc2,$acc2,#1
667         orr     $acc2,$acc2,$acc3,lsl#63
668         lsr     $acc3,$acc3,#1
669         stp     $acc0,$acc1,[$rp]
670         orr     $acc3,$acc3,$ap,lsl#63
671         stp     $acc2,$acc3,[$rp,#16]
672
673         ret
674 .size   __ecp_nistz256_div_by_2,.-__ecp_nistz256_div_by_2
675 ___
676 ########################################################################
677 # following subroutines are "literal" implemetation of those found in
678 # ecp_nistz256.c
679 #
680 ########################################################################
681 # void ecp_nistz256_point_double(P256_POINT *out,const P256_POINT *inp);
682 #
683 {
684 my ($S,$M,$Zsqr,$tmp0)=map(32*$_,(0..3));
685 # above map() describes stack layout with 4 temporary
686 # 256-bit vectors on top.
687 my ($rp_real,$ap_real) = map("x$_",(21,22));
688
689 $code.=<<___;
690 .globl  ecp_nistz256_point_double
691 .type   ecp_nistz256_point_double,%function
692 .align  5
693 ecp_nistz256_point_double:
694         stp     x29,x30,[sp,#-48]!
695         add     x29,sp,#0
696         stp     x19,x20,[sp,#16]
697         stp     x21,x22,[sp,#32]
698         sub     sp,sp,#32*4
699
700         ldp     $acc0,$acc1,[$ap,#32]
701          mov    $rp_real,$rp
702         ldp     $acc2,$acc3,[$ap,#48]
703          mov    $ap_real,$ap
704          ldr    $poly1,.Lpoly+8
705         mov     $t0,$acc0
706          ldr    $poly3,.Lpoly+24
707         mov     $t1,$acc1
708          ldp    $a0,$a1,[$ap_real,#64]  // forward load for p256_sqr_mont
709         mov     $t2,$acc2
710         mov     $t3,$acc3
711          ldp    $a2,$a3,[$ap_real,#64+16]
712         add     $rp,sp,#$S
713         bl      __ecp_nistz256_add      // p256_mul_by_2(S, in_y);
714
715         add     $rp,sp,#$Zsqr
716         bl      __ecp_nistz256_sqr_mont // p256_sqr_mont(Zsqr, in_z);
717
718         ldp     $t0,$t1,[$ap_real]
719         ldp     $t2,$t3,[$ap_real,#16]
720         mov     $a0,$acc0               // put Zsqr aside for p256_sub
721         mov     $a1,$acc1
722         mov     $a2,$acc2
723         mov     $a3,$acc3
724         add     $rp,sp,#$M
725         bl      __ecp_nistz256_add      // p256_add(M, Zsqr, in_x);
726
727         add     $bp,$ap_real,#0
728         mov     $acc0,$a0               // restore Zsqr
729         mov     $acc1,$a1
730          ldp    $a0,$a1,[sp,#$S]        // forward load for p256_sqr_mont
731         mov     $acc2,$a2
732         mov     $acc3,$a3
733          ldp    $a2,$a3,[sp,#$S+16]
734         add     $rp,sp,#$Zsqr
735         bl      __ecp_nistz256_sub_morf // p256_sub(Zsqr, in_x, Zsqr);
736
737         add     $rp,sp,#$S
738         bl      __ecp_nistz256_sqr_mont // p256_sqr_mont(S, S);
739
740         ldr     $bi,[$ap_real,#32]
741         ldp     $a0,$a1,[$ap_real,#64]
742         ldp     $a2,$a3,[$ap_real,#64+16]
743         add     $bp,$ap_real,#32
744         add     $rp,sp,#$tmp0
745         bl      __ecp_nistz256_mul_mont // p256_mul_mont(tmp0, in_z, in_y);
746
747         mov     $t0,$acc0
748         mov     $t1,$acc1
749          ldp    $a0,$a1,[sp,#$S]        // forward load for p256_sqr_mont
750         mov     $t2,$acc2
751         mov     $t3,$acc3
752          ldp    $a2,$a3,[sp,#$S+16]
753         add     $rp,$rp_real,#64
754         bl      __ecp_nistz256_add      // p256_mul_by_2(res_z, tmp0);
755
756         add     $rp,sp,#$tmp0
757         bl      __ecp_nistz256_sqr_mont // p256_sqr_mont(tmp0, S);
758
759          ldr    $bi,[sp,#$Zsqr]         // forward load for p256_mul_mont
760          ldp    $a0,$a1,[sp,#$M]
761          ldp    $a2,$a3,[sp,#$M+16]
762         add     $rp,$rp_real,#32
763         bl      __ecp_nistz256_div_by_2 // p256_div_by_2(res_y, tmp0);
764
765         add     $bp,sp,#$Zsqr
766         add     $rp,sp,#$M
767         bl      __ecp_nistz256_mul_mont // p256_mul_mont(M, M, Zsqr);
768
769         mov     $t0,$acc0               // duplicate M
770         mov     $t1,$acc1
771         mov     $t2,$acc2
772         mov     $t3,$acc3
773         mov     $a0,$acc0               // put M aside
774         mov     $a1,$acc1
775         mov     $a2,$acc2
776         mov     $a3,$acc3
777         add     $rp,sp,#$M
778         bl      __ecp_nistz256_add
779         mov     $t0,$a0                 // restore M
780         mov     $t1,$a1
781          ldr    $bi,[$ap_real]          // forward load for p256_mul_mont
782         mov     $t2,$a2
783          ldp    $a0,$a1,[sp,#$S]
784         mov     $t3,$a3
785          ldp    $a2,$a3,[sp,#$S+16]
786         bl      __ecp_nistz256_add      // p256_mul_by_3(M, M);
787
788         add     $bp,$ap_real,#0
789         add     $rp,sp,#$S
790         bl      __ecp_nistz256_mul_mont // p256_mul_mont(S, S, in_x);
791
792         mov     $t0,$acc0
793         mov     $t1,$acc1
794          ldp    $a0,$a1,[sp,#$M]        // forward load for p256_sqr_mont
795         mov     $t2,$acc2
796         mov     $t3,$acc3
797          ldp    $a2,$a3,[sp,#$M+16]
798         add     $rp,sp,#$tmp0
799         bl      __ecp_nistz256_add      // p256_mul_by_2(tmp0, S);
800
801         add     $rp,$rp_real,#0
802         bl      __ecp_nistz256_sqr_mont // p256_sqr_mont(res_x, M);
803
804         add     $bp,sp,#$tmp0
805         bl      __ecp_nistz256_sub_from // p256_sub(res_x, res_x, tmp0);
806
807         add     $bp,sp,#$S
808         add     $rp,sp,#$S
809         bl      __ecp_nistz256_sub_morf // p256_sub(S, S, res_x);
810
811         ldr     $bi,[sp,#$M]
812         mov     $a0,$acc0               // copy S
813         mov     $a1,$acc1
814         mov     $a2,$acc2
815         mov     $a3,$acc3
816         add     $bp,sp,#$M
817         bl      __ecp_nistz256_mul_mont // p256_mul_mont(S, S, M);
818
819         add     $bp,$rp_real,#32
820         add     $rp,$rp_real,#32
821         bl      __ecp_nistz256_sub_from // p256_sub(res_y, S, res_y);
822
823         add     sp,x29,#0               // destroy frame
824         ldp     x19,x20,[x29,#16]
825         ldp     x21,x22,[x29,#32]
826         ldp     x29,x30,[sp],#48
827         ret
828 .size   ecp_nistz256_point_double,.-ecp_nistz256_point_double
829 ___
830 }
831
832 ########################################################################
833 # void ecp_nistz256_point_add(P256_POINT *out,const P256_POINT *in1,
834 #                             const P256_POINT *in2);
835 {
836 my ($res_x,$res_y,$res_z,
837     $H,$Hsqr,$R,$Rsqr,$Hcub,
838     $U1,$U2,$S1,$S2)=map(32*$_,(0..11));
839 my ($Z1sqr, $Z2sqr) = ($Hsqr, $Rsqr);
840 # above map() describes stack layout with 12 temporary
841 # 256-bit vectors on top.
842 my ($rp_real,$ap_real,$bp_real,$in1infty,$in2infty,$temp)=map("x$_",(21..26));
843
844 $code.=<<___;
845 .globl  ecp_nistz256_point_add
846 .type   ecp_nistz256_point_add,%function
847 .align  5
848 ecp_nistz256_point_add:
849         stp     x29,x30,[sp,#-80]!
850         add     x29,sp,#0
851         stp     x19,x20,[sp,#16]
852         stp     x21,x22,[sp,#32]
853         stp     x23,x24,[sp,#48]
854         stp     x25,x26,[sp,#64]
855         sub     sp,sp,#32*12
856
857         ldp     $a0,$a1,[$bp]
858         ldp     $a2,$a3,[$bp,#16]
859         ldp     $t0,$t1,[$bp,#32]
860         ldp     $t2,$t3,[$bp,#48]
861          mov    $rp_real,$rp
862          mov    $ap_real,$ap
863          mov    $bp_real,$bp
864         orr     $a0,$a0,$a1
865         orr     $a2,$a2,$a3
866          ldp    $acc0,$acc1,[$ap]
867         orr     $t0,$t0,$t1
868         orr     $t2,$t2,$t3
869          ldp    $acc2,$acc3,[$ap,#16]
870         orr     $a0,$a0,$a2
871         orr     $t2,$t0,$t2
872          ldp    $t0,$t1,[$ap,#32]
873         orr     $in2infty,$a0,$t2
874         cmp     $in2infty,#0
875          ldp    $t2,$t3,[$ap,#48]
876         csetm   $in2infty,ne            // !in2infty
877
878          ldp    $a0,$a1,[$bp_real,#64]  // forward load for p256_sqr_mont
879         orr     $acc0,$acc0,$acc1
880         orr     $acc2,$acc2,$acc3
881          ldp    $a2,$a3,[$bp_real,#64+16]
882         orr     $t0,$t0,$t1
883         orr     $t2,$t2,$t3
884         orr     $acc0,$acc0,$acc2
885         orr     $t0,$t0,$t2
886         orr     $in1infty,$acc0,$t0
887         cmp     $in1infty,#0
888          ldr    $poly1,.Lpoly+8
889          ldr    $poly3,.Lpoly+24
890         csetm   $in1infty,ne            // !in1infty
891
892         add     $rp,sp,#$Z2sqr
893         bl      __ecp_nistz256_sqr_mont // p256_sqr_mont(Z2sqr, in2_z);
894
895         ldp     $a0,$a1,[$ap_real,#64]
896         ldp     $a2,$a3,[$ap_real,#64+16]
897         add     $rp,sp,#$Z1sqr
898         bl      __ecp_nistz256_sqr_mont // p256_sqr_mont(Z1sqr, in1_z);
899
900         ldr     $bi,[$bp_real,#64]
901         ldp     $a0,$a1,[sp,#$Z2sqr]
902         ldp     $a2,$a3,[sp,#$Z2sqr+16]
903         add     $bp,$bp_real,#64
904         add     $rp,sp,#$S1
905         bl      __ecp_nistz256_mul_mont // p256_mul_mont(S1, Z2sqr, in2_z);
906
907         ldr     $bi,[$ap_real,#64]
908         ldp     $a0,$a1,[sp,#$Z1sqr]
909         ldp     $a2,$a3,[sp,#$Z1sqr+16]
910         add     $bp,$ap_real,#64
911         add     $rp,sp,#$S2
912         bl      __ecp_nistz256_mul_mont // p256_mul_mont(S2, Z1sqr, in1_z);
913
914         ldr     $bi,[$ap_real,#32]
915         ldp     $a0,$a1,[sp,#$S1]
916         ldp     $a2,$a3,[sp,#$S1+16]
917         add     $bp,$ap_real,#32
918         add     $rp,sp,#$S1
919         bl      __ecp_nistz256_mul_mont // p256_mul_mont(S1, S1, in1_y);
920
921         ldr     $bi,[$bp_real,#32]
922         ldp     $a0,$a1,[sp,#$S2]
923         ldp     $a2,$a3,[sp,#$S2+16]
924         add     $bp,$bp_real,#32
925         add     $rp,sp,#$S2
926         bl      __ecp_nistz256_mul_mont // p256_mul_mont(S2, S2, in2_y);
927
928         add     $bp,sp,#$S1
929          ldr    $bi,[sp,#$Z2sqr]        // forward load for p256_mul_mont
930          ldp    $a0,$a1,[$ap_real]
931          ldp    $a2,$a3,[$ap_real,#16]
932         add     $rp,sp,#$R
933         bl      __ecp_nistz256_sub_from // p256_sub(R, S2, S1);
934
935         orr     $acc0,$acc0,$acc1       // see if result is zero
936         orr     $acc2,$acc2,$acc3
937         orr     $temp,$acc0,$acc2
938
939         add     $bp,sp,#$Z2sqr
940         add     $rp,sp,#$U1
941         bl      __ecp_nistz256_mul_mont // p256_mul_mont(U1, in1_x, Z2sqr);
942
943         ldr     $bi,[sp,#$Z1sqr]
944         ldp     $a0,$a1,[$bp_real]
945         ldp     $a2,$a3,[$bp_real,#16]
946         add     $bp,sp,#$Z1sqr
947         add     $rp,sp,#$U2
948         bl      __ecp_nistz256_mul_mont // p256_mul_mont(U2, in2_x, Z1sqr);
949
950         add     $bp,sp,#$U1
951          ldp    $a0,$a1,[sp,#$R]        // forward load for p256_sqr_mont
952          ldp    $a2,$a3,[sp,#$R+16]
953         add     $rp,sp,#$H
954         bl      __ecp_nistz256_sub_from // p256_sub(H, U2, U1);
955
956         orr     $acc0,$acc0,$acc1       // see if result is zero
957         orr     $acc2,$acc2,$acc3
958         orr     $acc0,$acc0,$acc2
959         tst     $acc0,$acc0
960         b.ne    .Ladd_proceed           // is_equal(U1,U2)?
961
962         tst     $in1infty,$in2infty
963         b.eq    .Ladd_proceed           // (in1infty || in2infty)?
964
965         tst     $temp,$temp
966         b.eq    .Ladd_proceed           // is_equal(S1,S2)?
967
968         eor     $a0,$a0,$a0
969         eor     $a1,$a1,$a1
970         stp     $a0,$a1,[$rp_real]
971         stp     $a0,$a1,[$rp_real,#16]
972         stp     $a0,$a1,[$rp_real,#32]
973         stp     $a0,$a1,[$rp_real,#48]
974         stp     $a0,$a1,[$rp_real,#64]
975         stp     $a0,$a1,[$rp_real,#80]
976         b       .Ladd_done
977
978 .align  4
979 .Ladd_proceed:
980         add     $rp,sp,#$Rsqr
981         bl      __ecp_nistz256_sqr_mont // p256_sqr_mont(Rsqr, R);
982
983         ldr     $bi,[$ap_real,#64]
984         ldp     $a0,$a1,[sp,#$H]
985         ldp     $a2,$a3,[sp,#$H+16]
986         add     $bp,$ap_real,#64
987         add     $rp,sp,#$res_z
988         bl      __ecp_nistz256_mul_mont // p256_mul_mont(res_z, H, in1_z);
989
990         ldp     $a0,$a1,[sp,#$H]
991         ldp     $a2,$a3,[sp,#$H+16]
992         add     $rp,sp,#$Hsqr
993         bl      __ecp_nistz256_sqr_mont // p256_sqr_mont(Hsqr, H);
994
995         ldr     $bi,[$bp_real,#64]
996         ldp     $a0,$a1,[sp,#$res_z]
997         ldp     $a2,$a3,[sp,#$res_z+16]
998         add     $bp,$bp_real,#64
999         add     $rp,sp,#$res_z
1000         bl      __ecp_nistz256_mul_mont // p256_mul_mont(res_z, res_z, in2_z);
1001
1002         ldr     $bi,[sp,#$H]
1003         ldp     $a0,$a1,[sp,#$Hsqr]
1004         ldp     $a2,$a3,[sp,#$Hsqr+16]
1005         add     $bp,sp,#$H
1006         add     $rp,sp,#$Hcub
1007         bl      __ecp_nistz256_mul_mont // p256_mul_mont(Hcub, Hsqr, H);
1008
1009         ldr     $bi,[sp,#$Hsqr]
1010         ldp     $a0,$a1,[sp,#$U1]
1011         ldp     $a2,$a3,[sp,#$U1+16]
1012         add     $bp,sp,#$Hsqr
1013         add     $rp,sp,#$U2
1014         bl      __ecp_nistz256_mul_mont // p256_mul_mont(U2, U1, Hsqr);
1015
1016         mov     $t0,$acc0
1017         mov     $t1,$acc1
1018         mov     $t2,$acc2
1019         mov     $t3,$acc3
1020         add     $rp,sp,#$Hsqr
1021         bl      __ecp_nistz256_add      // p256_mul_by_2(Hsqr, U2);
1022
1023         add     $bp,sp,#$Rsqr
1024         add     $rp,sp,#$res_x
1025         bl      __ecp_nistz256_sub_morf // p256_sub(res_x, Rsqr, Hsqr);
1026
1027         add     $bp,sp,#$Hcub
1028         bl      __ecp_nistz256_sub_from //  p256_sub(res_x, res_x, Hcub);
1029
1030         add     $bp,sp,#$U2
1031          ldr    $bi,[sp,#$Hcub]         // forward load for p256_mul_mont
1032          ldp    $a0,$a1,[sp,#$S1]
1033          ldp    $a2,$a3,[sp,#$S1+16]
1034         add     $rp,sp,#$res_y
1035         bl      __ecp_nistz256_sub_morf // p256_sub(res_y, U2, res_x);
1036
1037         add     $bp,sp,#$Hcub
1038         add     $rp,sp,#$S2
1039         bl      __ecp_nistz256_mul_mont // p256_mul_mont(S2, S1, Hcub);
1040
1041         ldr     $bi,[sp,#$R]
1042         ldp     $a0,$a1,[sp,#$res_y]
1043         ldp     $a2,$a3,[sp,#$res_y+16]
1044         add     $bp,sp,#$R
1045         add     $rp,sp,#$res_y
1046         bl      __ecp_nistz256_mul_mont // p256_mul_mont(res_y, res_y, R);
1047
1048         add     $bp,sp,#$S2
1049         bl      __ecp_nistz256_sub_from // p256_sub(res_y, res_y, S2);
1050
1051         ldp     $a0,$a1,[sp,#$res_x]            // res
1052         ldp     $a2,$a3,[sp,#$res_x+16]
1053         ldp     $t0,$t1,[$bp_real]              // in2
1054         ldp     $t2,$t3,[$bp_real,#16]
1055 ___
1056 for($i=0;$i<64;$i+=32) {                # conditional moves
1057 $code.=<<___;
1058         ldp     $acc0,$acc1,[$ap_real,#$i]      // in1
1059         cmp     $in1infty,#0                    // !$in1intfy, remember?
1060         ldp     $acc2,$acc3,[$ap_real,#$i+16]
1061         csel    $t0,$a0,$t0,ne
1062         csel    $t1,$a1,$t1,ne
1063         ldp     $a0,$a1,[sp,#$res_x+$i+32]      // res
1064         csel    $t2,$a2,$t2,ne
1065         csel    $t3,$a3,$t3,ne
1066         cmp     $in2infty,#0                    // !$in2intfy, remember?
1067         ldp     $a2,$a3,[sp,#$res_x+$i+48]
1068         csel    $acc0,$t0,$acc0,ne
1069         csel    $acc1,$t1,$acc1,ne
1070         ldp     $t0,$t1,[$bp_real,#$i+32]       // in2
1071         csel    $acc2,$t2,$acc2,ne
1072         csel    $acc3,$t3,$acc3,ne
1073         ldp     $t2,$t3,[$bp_real,#$i+48]
1074         stp     $acc0,$acc1,[$rp_real,#$i]
1075         stp     $acc2,$acc3,[$rp_real,#$i+16]
1076 ___
1077 }
1078 $code.=<<___;
1079         ldp     $acc0,$acc1,[$ap_real,#$i]      // in1
1080         cmp     $in1infty,#0                    // !$in1intfy, remember?
1081         ldp     $acc2,$acc3,[$ap_real,#$i+16]
1082         csel    $t0,$a0,$t0,ne
1083         csel    $t1,$a1,$t1,ne
1084         csel    $t2,$a2,$t2,ne
1085         csel    $t3,$a3,$t3,ne
1086         cmp     $in2infty,#0                    // !$in2intfy, remember?
1087         csel    $acc0,$t0,$acc0,ne
1088         csel    $acc1,$t1,$acc1,ne
1089         csel    $acc2,$t2,$acc2,ne
1090         csel    $acc3,$t3,$acc3,ne
1091         stp     $acc0,$acc1,[$rp_real,#$i]
1092         stp     $acc2,$acc3,[$rp_real,#$i+16]
1093
1094 .Ladd_done:
1095         add     sp,x29,#0       // destroy frame
1096         ldp     x19,x20,[x29,#16]
1097         ldp     x21,x22,[x29,#32]
1098         ldp     x23,x24,[x29,#48]
1099         ldp     x25,x26,[x29,#64]
1100         ldp     x29,x30,[sp],#80
1101         ret
1102 .size   ecp_nistz256_point_add,.-ecp_nistz256_point_add
1103 ___
1104 }
1105
1106 ########################################################################
1107 # void ecp_nistz256_point_add_affine(P256_POINT *out,const P256_POINT *in1,
1108 #                                    const P256_POINT_AFFINE *in2);
1109 {
1110 my ($res_x,$res_y,$res_z,
1111     $U2,$S2,$H,$R,$Hsqr,$Hcub,$Rsqr)=map(32*$_,(0..9));
1112 my $Z1sqr = $S2;
1113 # above map() describes stack layout with 10 temporary
1114 # 256-bit vectors on top.
1115 my ($rp_real,$ap_real,$bp_real,$in1infty,$in2infty,$temp)=map("x$_",(21..26));
1116
1117 $code.=<<___;
1118 .globl  ecp_nistz256_point_add_affine
1119 .type   ecp_nistz256_point_add_affine,%function
1120 .align  5
1121 ecp_nistz256_point_add_affine:
1122         stp     x29,x30,[sp,#-80]!
1123         add     x29,sp,#0
1124         stp     x19,x20,[sp,#16]
1125         stp     x21,x22,[sp,#32]
1126         stp     x23,x24,[sp,#48]
1127         stp     x25,x26,[sp,#64]
1128         sub     sp,sp,#32*10
1129
1130         mov     $rp_real,$rp
1131         mov     $ap_real,$ap
1132         mov     $bp_real,$bp
1133         ldr     $poly1,.Lpoly+8
1134         ldr     $poly3,.Lpoly+24
1135
1136         ldp     $a0,$a1,[$ap]
1137         ldp     $a2,$a3,[$ap,#16]
1138         ldp     $t0,$t1,[$ap,#32]
1139         ldp     $t2,$t3,[$ap,#48]
1140         orr     $a0,$a0,$a1
1141         orr     $a2,$a2,$a3
1142         orr     $t0,$t0,$t1
1143         orr     $t2,$t2,$t3
1144         orr     $a0,$a0,$a2
1145         orr     $t0,$t0,$t2
1146         orr     $in1infty,$a0,$t0
1147         cmp     $in1infty,#0
1148         csetm   $in1infty,ne            // !in1infty
1149
1150         ldp     $a0,$a1,[$bp]
1151         ldp     $a2,$a3,[$bp,#16]
1152         ldp     $t0,$t1,[$bp,#32]
1153         ldp     $t2,$t3,[$bp,#48]
1154         orr     $a0,$a0,$a1
1155         orr     $a2,$a2,$a3
1156         orr     $t0,$t0,$t1
1157         orr     $t2,$t2,$t3
1158         orr     $a0,$a0,$a2
1159         orr     $t0,$t0,$t2
1160         orr     $in2infty,$a0,$t0
1161         cmp     $in2infty,#0
1162         csetm   $in2infty,ne            // !in2infty
1163
1164         ldp     $a0,$a1,[$ap_real,#64]
1165         ldp     $a2,$a3,[$ap_real,#64+16]
1166         add     $rp,sp,#$Z1sqr
1167         bl      __ecp_nistz256_sqr_mont // p256_sqr_mont(Z1sqr, in1_z);
1168
1169         mov     $a0,$acc0
1170         mov     $a1,$acc1
1171         mov     $a2,$acc2
1172         mov     $a3,$acc3
1173         ldr     $bi,[$bp_real]
1174         add     $bp,$bp_real,#0
1175         add     $rp,sp,#$U2
1176         bl      __ecp_nistz256_mul_mont // p256_mul_mont(U2, Z1sqr, in2_x);
1177
1178         add     $bp,$ap_real,#0
1179          ldr    $bi,[$ap_real,#64]      // forward load for p256_mul_mont
1180          ldp    $a0,$a1,[sp,#$Z1sqr]
1181          ldp    $a2,$a3,[sp,#$Z1sqr+16]
1182         add     $rp,sp,#$H
1183         bl      __ecp_nistz256_sub_from // p256_sub(H, U2, in1_x);
1184
1185         add     $bp,$ap_real,#64
1186         add     $rp,sp,#$S2
1187         bl      __ecp_nistz256_mul_mont // p256_mul_mont(S2, Z1sqr, in1_z);
1188
1189         ldr     $bi,[$ap_real,#64]
1190         ldp     $a0,$a1,[sp,#$H]
1191         ldp     $a2,$a3,[sp,#$H+16]
1192         add     $bp,$ap_real,#64
1193         add     $rp,sp,#$res_z
1194         bl      __ecp_nistz256_mul_mont // p256_mul_mont(res_z, H, in1_z);
1195
1196         ldr     $bi,[$bp_real,#32]
1197         ldp     $a0,$a1,[sp,#$S2]
1198         ldp     $a2,$a3,[sp,#$S2+16]
1199         add     $bp,$bp_real,#32
1200         add     $rp,sp,#$S2
1201         bl      __ecp_nistz256_mul_mont // p256_mul_mont(S2, S2, in2_y);
1202
1203         add     $bp,$ap_real,#32
1204          ldp    $a0,$a1,[sp,#$H]        // forward load for p256_sqr_mont
1205          ldp    $a2,$a3,[sp,#$H+16]
1206         add     $rp,sp,#$R
1207         bl      __ecp_nistz256_sub_from // p256_sub(R, S2, in1_y);
1208
1209         add     $rp,sp,#$Hsqr
1210         bl      __ecp_nistz256_sqr_mont // p256_sqr_mont(Hsqr, H);
1211
1212         ldp     $a0,$a1,[sp,#$R]
1213         ldp     $a2,$a3,[sp,#$R+16]
1214         add     $rp,sp,#$Rsqr
1215         bl      __ecp_nistz256_sqr_mont // p256_sqr_mont(Rsqr, R);
1216
1217         ldr     $bi,[sp,#$H]
1218         ldp     $a0,$a1,[sp,#$Hsqr]
1219         ldp     $a2,$a3,[sp,#$Hsqr+16]
1220         add     $bp,sp,#$H
1221         add     $rp,sp,#$Hcub
1222         bl      __ecp_nistz256_mul_mont // p256_mul_mont(Hcub, Hsqr, H);
1223
1224         ldr     $bi,[$ap_real]
1225         ldp     $a0,$a1,[sp,#$Hsqr]
1226         ldp     $a2,$a3,[sp,#$Hsqr+16]
1227         add     $bp,$ap_real,#0
1228         add     $rp,sp,#$U2
1229         bl      __ecp_nistz256_mul_mont // p256_mul_mont(U2, in1_x, Hsqr);
1230
1231         mov     $t0,$acc0
1232         mov     $t1,$acc1
1233         mov     $t2,$acc2
1234         mov     $t3,$acc3
1235         add     $rp,sp,#$Hsqr
1236         bl      __ecp_nistz256_add      // p256_mul_by_2(Hsqr, U2);
1237
1238         add     $bp,sp,#$Rsqr
1239         add     $rp,sp,#$res_x
1240         bl      __ecp_nistz256_sub_morf // p256_sub(res_x, Rsqr, Hsqr);
1241
1242         add     $bp,sp,#$Hcub
1243         bl      __ecp_nistz256_sub_from //  p256_sub(res_x, res_x, Hcub);
1244
1245         add     $bp,sp,#$U2
1246          ldr    $bi,[$ap_real,#32]      // forward load for p256_mul_mont
1247          ldp    $a0,$a1,[sp,#$Hcub]
1248          ldp    $a2,$a3,[sp,#$Hcub+16]
1249         add     $rp,sp,#$res_y
1250         bl      __ecp_nistz256_sub_morf // p256_sub(res_y, U2, res_x);
1251
1252         add     $bp,$ap_real,#32
1253         add     $rp,sp,#$S2
1254         bl      __ecp_nistz256_mul_mont // p256_mul_mont(S2, in1_y, Hcub);
1255
1256         ldr     $bi,[sp,#$R]
1257         ldp     $a0,$a1,[sp,#$res_y]
1258         ldp     $a2,$a3,[sp,#$res_y+16]
1259         add     $bp,sp,#$R
1260         add     $rp,sp,#$res_y
1261         bl      __ecp_nistz256_mul_mont // p256_mul_mont(res_y, res_y, R);
1262
1263         add     $bp,sp,#$S2
1264         bl      __ecp_nistz256_sub_from // p256_sub(res_y, res_y, S2);
1265
1266         ldp     $a0,$a1,[sp,#$res_x]            // res
1267         ldp     $a2,$a3,[sp,#$res_x+16]
1268         ldp     $t0,$t1,[$bp_real]              // in2
1269         ldp     $t2,$t3,[$bp_real,#16]
1270 ___
1271 for($i=0;$i<64;$i+=32) {                # conditional moves
1272 $code.=<<___;
1273         ldp     $acc0,$acc1,[$ap_real,#$i]      // in1
1274         cmp     $in1infty,#0                    // !$in1intfy, remember?
1275         ldp     $acc2,$acc3,[$ap_real,#$i+16]
1276         csel    $t0,$a0,$t0,ne
1277         csel    $t1,$a1,$t1,ne
1278         ldp     $a0,$a1,[sp,#$res_x+$i+32]      // res
1279         csel    $t2,$a2,$t2,ne
1280         csel    $t3,$a3,$t3,ne
1281         cmp     $in2infty,#0                    // !$in2intfy, remember?
1282         ldp     $a2,$a3,[sp,#$res_x+$i+48]
1283         csel    $acc0,$t0,$acc0,ne
1284         csel    $acc1,$t1,$acc1,ne
1285         ldp     $t0,$t1,[$bp_real,#$i+32]       // in2
1286         csel    $acc2,$t2,$acc2,ne
1287         csel    $acc3,$t3,$acc3,ne
1288         ldp     $t2,$t3,[$bp_real,#$i+48]
1289         stp     $acc0,$acc1,[$rp_real,#$i]
1290         stp     $acc2,$acc3,[$rp_real,#$i+16]
1291 ___
1292 }
1293 $code.=<<___;
1294         ldp     $acc0,$acc1,[$ap_real,#$i]      // in1
1295         cmp     $in1infty,#0                    // !$in1intfy, remember?
1296         ldp     $acc2,$acc3,[$ap_real,#$i+16]
1297         csel    $t0,$a0,$t0,ne
1298         csel    $t1,$a1,$t1,ne
1299         csel    $t2,$a2,$t2,ne
1300         csel    $t3,$a3,$t3,ne
1301         cmp     $in2infty,#0                    // !$in2intfy, remember?
1302         csel    $acc0,$t0,$acc0,ne
1303         csel    $acc1,$t1,$acc1,ne
1304         csel    $acc2,$t2,$acc2,ne
1305         csel    $acc3,$t3,$acc3,ne
1306         stp     $acc0,$acc1,[$rp_real,#$i]
1307         stp     $acc2,$acc3,[$rp_real,#$i+16]
1308
1309         add     sp,x29,#0               // destroy frame
1310         ldp     x19,x20,[x29,#16]
1311         ldp     x21,x22,[x29,#32]
1312         ldp     x23,x24,[x29,#48]
1313         ldp     x25,x26,[x29,#64]
1314         ldp     x29,x30,[sp],#80
1315         ret
1316 .size   ecp_nistz256_point_add_affine,.-ecp_nistz256_point_add_affine
1317 ___
1318 }       }
1319
1320 ########################################################################
1321 # scatter-gather subroutines
1322 {
1323 my ($out,$inp,$index,$mask)=map("x$_",(0..3));
1324 $code.=<<___;
1325 // void ecp_nistz256_scatter_w5(void *x0,const P256_POINT *x1,
1326 //                                       int x2);
1327 .globl  ecp_nistz256_scatter_w5
1328 .type   ecp_nistz256_scatter_w5,%function
1329 .align  4
1330 ecp_nistz256_scatter_w5:
1331         stp     x29,x30,[sp,#-16]!
1332         add     x29,sp,#0
1333
1334         add     $out,$out,$index,lsl#2
1335
1336         ldp     x4,x5,[$inp]            // X
1337         ldp     x6,x7,[$inp,#16]
1338         str     w4,[$out,#64*0-4]
1339         lsr     x4,x4,#32
1340         str     w5,[$out,#64*1-4]
1341         lsr     x5,x5,#32
1342         str     w6,[$out,#64*2-4]
1343         lsr     x6,x6,#32
1344         str     w7,[$out,#64*3-4]
1345         lsr     x7,x7,#32
1346         str     w4,[$out,#64*4-4]
1347         str     w5,[$out,#64*5-4]
1348         str     w6,[$out,#64*6-4]
1349         str     w7,[$out,#64*7-4]
1350         add     $out,$out,#64*8
1351
1352         ldp     x4,x5,[$inp,#32]        // Y
1353         ldp     x6,x7,[$inp,#48]
1354         str     w4,[$out,#64*0-4]
1355         lsr     x4,x4,#32
1356         str     w5,[$out,#64*1-4]
1357         lsr     x5,x5,#32
1358         str     w6,[$out,#64*2-4]
1359         lsr     x6,x6,#32
1360         str     w7,[$out,#64*3-4]
1361         lsr     x7,x7,#32
1362         str     w4,[$out,#64*4-4]
1363         str     w5,[$out,#64*5-4]
1364         str     w6,[$out,#64*6-4]
1365         str     w7,[$out,#64*7-4]
1366         add     $out,$out,#64*8
1367
1368         ldp     x4,x5,[$inp,#64]        // Z
1369         ldp     x6,x7,[$inp,#80]
1370         str     w4,[$out,#64*0-4]
1371         lsr     x4,x4,#32
1372         str     w5,[$out,#64*1-4]
1373         lsr     x5,x5,#32
1374         str     w6,[$out,#64*2-4]
1375         lsr     x6,x6,#32
1376         str     w7,[$out,#64*3-4]
1377         lsr     x7,x7,#32
1378         str     w4,[$out,#64*4-4]
1379         str     w5,[$out,#64*5-4]
1380         str     w6,[$out,#64*6-4]
1381         str     w7,[$out,#64*7-4]
1382
1383         ldr     x29,[sp],#16
1384         ret
1385 .size   ecp_nistz256_scatter_w5,.-ecp_nistz256_scatter_w5
1386
1387 // void ecp_nistz256_gather_w5(P256_POINT *x0,const void *x1,
1388 //                                            int x2);
1389 .globl  ecp_nistz256_gather_w5
1390 .type   ecp_nistz256_gather_w5,%function
1391 .align  4
1392 ecp_nistz256_gather_w5:
1393         stp     x29,x30,[sp,#-16]!
1394         add     x29,sp,#0
1395
1396         cmp     $index,xzr
1397         csetm   x3,ne
1398         add     $index,$index,x3
1399         add     $inp,$inp,$index,lsl#2
1400
1401         ldr     w4,[$inp,#64*0]
1402         ldr     w5,[$inp,#64*1]
1403         ldr     w6,[$inp,#64*2]
1404         ldr     w7,[$inp,#64*3]
1405         ldr     w8,[$inp,#64*4]
1406         ldr     w9,[$inp,#64*5]
1407         ldr     w10,[$inp,#64*6]
1408         ldr     w11,[$inp,#64*7]
1409         add     $inp,$inp,#64*8
1410         orr     x4,x4,x8,lsl#32
1411         orr     x5,x5,x9,lsl#32
1412         orr     x6,x6,x10,lsl#32
1413         orr     x7,x7,x11,lsl#32
1414         csel    x4,x4,xzr,ne
1415         csel    x5,x5,xzr,ne
1416         csel    x6,x6,xzr,ne
1417         csel    x7,x7,xzr,ne
1418         stp     x4,x5,[$out]            // X
1419         stp     x6,x7,[$out,#16]
1420
1421         ldr     w4,[$inp,#64*0]
1422         ldr     w5,[$inp,#64*1]
1423         ldr     w6,[$inp,#64*2]
1424         ldr     w7,[$inp,#64*3]
1425         ldr     w8,[$inp,#64*4]
1426         ldr     w9,[$inp,#64*5]
1427         ldr     w10,[$inp,#64*6]
1428         ldr     w11,[$inp,#64*7]
1429         add     $inp,$inp,#64*8
1430         orr     x4,x4,x8,lsl#32
1431         orr     x5,x5,x9,lsl#32
1432         orr     x6,x6,x10,lsl#32
1433         orr     x7,x7,x11,lsl#32
1434         csel    x4,x4,xzr,ne
1435         csel    x5,x5,xzr,ne
1436         csel    x6,x6,xzr,ne
1437         csel    x7,x7,xzr,ne
1438         stp     x4,x5,[$out,#32]        // Y
1439         stp     x6,x7,[$out,#48]
1440
1441         ldr     w4,[$inp,#64*0]
1442         ldr     w5,[$inp,#64*1]
1443         ldr     w6,[$inp,#64*2]
1444         ldr     w7,[$inp,#64*3]
1445         ldr     w8,[$inp,#64*4]
1446         ldr     w9,[$inp,#64*5]
1447         ldr     w10,[$inp,#64*6]
1448         ldr     w11,[$inp,#64*7]
1449         orr     x4,x4,x8,lsl#32
1450         orr     x5,x5,x9,lsl#32
1451         orr     x6,x6,x10,lsl#32
1452         orr     x7,x7,x11,lsl#32
1453         csel    x4,x4,xzr,ne
1454         csel    x5,x5,xzr,ne
1455         csel    x6,x6,xzr,ne
1456         csel    x7,x7,xzr,ne
1457         stp     x4,x5,[$out,#64]        // Z
1458         stp     x6,x7,[$out,#80]
1459
1460         ldr     x29,[sp],#16
1461         ret
1462 .size   ecp_nistz256_gather_w5,.-ecp_nistz256_gather_w5
1463
1464 // void ecp_nistz256_scatter_w7(void *x0,const P256_POINT_AFFINE *x1,
1465 //                                       int x2);
1466 .globl  ecp_nistz256_scatter_w7
1467 .type   ecp_nistz256_scatter_w7,%function
1468 .align  4
1469 ecp_nistz256_scatter_w7:
1470         stp     x29,x30,[sp,#-16]!
1471         add     x29,sp,#0
1472
1473         add     $out,$out,$index
1474         mov     $index,#64/8
1475 .Loop_scatter_w7:
1476         ldr     x3,[$inp],#8
1477         subs    $index,$index,#1
1478         prfm    pstl1strm,[$out,#4096+64*0]
1479         prfm    pstl1strm,[$out,#4096+64*1]
1480         prfm    pstl1strm,[$out,#4096+64*2]
1481         prfm    pstl1strm,[$out,#4096+64*3]
1482         prfm    pstl1strm,[$out,#4096+64*4]
1483         prfm    pstl1strm,[$out,#4096+64*5]
1484         prfm    pstl1strm,[$out,#4096+64*6]
1485         prfm    pstl1strm,[$out,#4096+64*7]
1486         strb    w3,[$out,#64*0-1]
1487         lsr     x3,x3,#8
1488         strb    w3,[$out,#64*1-1]
1489         lsr     x3,x3,#8
1490         strb    w3,[$out,#64*2-1]
1491         lsr     x3,x3,#8
1492         strb    w3,[$out,#64*3-1]
1493         lsr     x3,x3,#8
1494         strb    w3,[$out,#64*4-1]
1495         lsr     x3,x3,#8
1496         strb    w3,[$out,#64*5-1]
1497         lsr     x3,x3,#8
1498         strb    w3,[$out,#64*6-1]
1499         lsr     x3,x3,#8
1500         strb    w3,[$out,#64*7-1]
1501         add     $out,$out,#64*8
1502         b.ne    .Loop_scatter_w7
1503
1504         ldr     x29,[sp],#16
1505         ret
1506 .size   ecp_nistz256_scatter_w7,.-ecp_nistz256_scatter_w7
1507
1508 // void ecp_nistz256_gather_w7(P256_POINT_AFFINE *x0,const void *x1,
1509 //                                                   int x2);
1510 .globl  ecp_nistz256_gather_w7
1511 .type   ecp_nistz256_gather_w7,%function
1512 .align  4
1513 ecp_nistz256_gather_w7:
1514         stp     x29,x30,[sp,#-16]!
1515         add     x29,sp,#0
1516
1517         cmp     $index,xzr
1518         csetm   x3,ne
1519         add     $index,$index,x3
1520         add     $inp,$inp,$index
1521         mov     $index,#64/8
1522         nop
1523 .Loop_gather_w7:
1524         ldrb    w4,[$inp,#64*0]
1525         prfm    pldl1strm,[$inp,#4096+64*0]
1526         subs    $index,$index,#1
1527         ldrb    w5,[$inp,#64*1]
1528         prfm    pldl1strm,[$inp,#4096+64*1]
1529         ldrb    w6,[$inp,#64*2]
1530         prfm    pldl1strm,[$inp,#4096+64*2]
1531         ldrb    w7,[$inp,#64*3]
1532         prfm    pldl1strm,[$inp,#4096+64*3]
1533         ldrb    w8,[$inp,#64*4]
1534         prfm    pldl1strm,[$inp,#4096+64*4]
1535         ldrb    w9,[$inp,#64*5]
1536         prfm    pldl1strm,[$inp,#4096+64*5]
1537         ldrb    w10,[$inp,#64*6]
1538         prfm    pldl1strm,[$inp,#4096+64*6]
1539         ldrb    w11,[$inp,#64*7]
1540         prfm    pldl1strm,[$inp,#4096+64*7]
1541         add     $inp,$inp,#64*8
1542         orr     x4,x4,x5,lsl#8
1543         orr     x6,x6,x7,lsl#8
1544         orr     x8,x8,x9,lsl#8
1545         orr     x4,x4,x6,lsl#16
1546         orr     x10,x10,x11,lsl#8
1547         orr     x4,x4,x8,lsl#32
1548         orr     x4,x4,x10,lsl#48
1549         and     x4,x4,x3
1550         str     x4,[$out],#8
1551         b.ne    .Loop_gather_w7
1552
1553         ldr     x29,[sp],#16
1554         ret
1555 .size   ecp_nistz256_gather_w7,.-ecp_nistz256_gather_w7
1556 ___
1557 }
1558
1559 foreach (split("\n",$code)) {
1560         s/\`([^\`]*)\`/eval $1/ge;
1561
1562         print $_,"\n";
1563 }
1564 close STDOUT;   # enforce flush