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