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