ec/asm/ecp_nistz256-x86_64.pl: get corner case logic right.
[openssl.git] / crypto / ec / asm / ecp_nistz256-x86_64.pl
1 #!/usr/bin/env perl
2
3 ##############################################################################
4 #                                                                            #
5 # Copyright 2014 Intel Corporation                                           #
6 #                                                                            #
7 # Licensed under the Apache License, Version 2.0 (the "License");            #
8 # you may not use this file except in compliance with the License.           #
9 # You may obtain a copy of the License at                                    #
10 #                                                                            #
11 #    http://www.apache.org/licenses/LICENSE-2.0                              #
12 #                                                                            #
13 # Unless required by applicable law or agreed to in writing, software        #
14 # distributed under the License is distributed on an "AS IS" BASIS,          #
15 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
16 # See the License for the specific language governing permissions and        #
17 # limitations under the License.                                             #
18 #                                                                            #
19 ##############################################################################
20 #                                                                            #
21 #  Developers and authors:                                                   #
22 #  Shay Gueron (1, 2), and Vlad Krasnov (1)                                  #
23 #  (1) Intel Corporation, Israel Development Center                          #
24 #  (2) University of Haifa                                                   #
25 #  Reference:                                                                #
26 #  S.Gueron and V.Krasnov, "Fast Prime Field Elliptic Curve Cryptography with#
27 #                           256 Bit Primes"                                  #
28 #                                                                            #
29 ##############################################################################
30
31 # Further optimization by <appro@openssl.org>:
32 #
33 #               this/original   with/without -DECP_NISTZ256_ASM(*)
34 # Opteron       +12-49%         +110-150%
35 # Bulldozer     +14-45%         +175-210%
36 # P4            +18-46%         n/a :-(
37 # Westmere      +12-34%         +80-87%
38 # Sandy Bridge  +9-35%          +110-120%
39 # Ivy Bridge    +9-35%          +110-125%
40 # Haswell       +8-37%          +140-160%
41 # Broadwell     +18-58%         +145-210%
42 # Atom          +15-50%         +130-180%
43 # VIA Nano      +43-160%        +300-480%
44 #
45 # (*)   "without -DECP_NISTZ256_ASM" refers to build with
46 #       "enable-ec_nistp_64_gcc_128";
47 #
48 # Ranges denote minimum and maximum improvement coefficients depending
49 # on benchmark. Lower coefficients are for ECDSA sign, relatively fastest
50 # server-side operation. Keep in mind that +100% means 2x improvement.
51
52 $flavour = shift;
53 $output  = shift;
54 if ($flavour =~ /\./) { $output = $flavour; undef $flavour; }
55
56 $win64=0; $win64=1 if ($flavour =~ /[nm]asm|mingw64/ || $output =~ /\.asm$/);
57
58 $0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1;
59 ( $xlate="${dir}x86_64-xlate.pl" and -f $xlate ) or
60 ( $xlate="${dir}../../perlasm/x86_64-xlate.pl" and -f $xlate) or
61 die "can't locate x86_64-xlate.pl";
62
63 open OUT,"| \"$^X\" $xlate $flavour $output";
64 *STDOUT=*OUT;
65
66 if (`$ENV{CC} -Wa,-v -c -o /dev/null -x assembler /dev/null 2>&1`
67                 =~ /GNU assembler version ([2-9]\.[0-9]+)/) {
68         $avx = ($1>=2.19) + ($1>=2.22);
69         $addx = ($1>=2.23);
70 }
71
72 if (!$addx && $win64 && ($flavour =~ /nasm/ || $ENV{ASM} =~ /nasm/) &&
73             `nasm -v 2>&1` =~ /NASM version ([2-9]\.[0-9]+)/) {
74         $avx = ($1>=2.09) + ($1>=2.10);
75         $addx = ($1>=2.10);
76 }
77
78 if (!$addx && $win64 && ($flavour =~ /masm/ || $ENV{ASM} =~ /ml64/) &&
79             `ml64 2>&1` =~ /Version ([0-9]+)\./) {
80         $avx = ($1>=10) + ($1>=11);
81         $addx = ($1>=12);
82 }
83
84 if (!$addx && `$ENV{CC} -v 2>&1` =~ /((?:^clang|LLVM) version|.*based on LLVM) ([3-9])\.([0-9]+)/) {
85         my $ver = $2 + $3/100.0;        # 3.1->3.01, 3.10->3.10
86         $avx = ($ver>=3.0) + ($ver>=3.01);
87         $addx = ($ver>=3.03);
88 }
89
90 $code.=<<___;
91 .text
92 .extern OPENSSL_ia32cap_P
93
94 # The polynomial
95 .align 64
96 .Lpoly:
97 .quad 0xffffffffffffffff, 0x00000000ffffffff, 0x0000000000000000, 0xffffffff00000001
98
99 # 2^512 mod P precomputed for NIST P256 polynomial
100 .LRR:
101 .quad 0x0000000000000003, 0xfffffffbffffffff, 0xfffffffffffffffe, 0x00000004fffffffd
102
103 .LOne:
104 .long 1,1,1,1,1,1,1,1
105 .LTwo:
106 .long 2,2,2,2,2,2,2,2
107 .LThree:
108 .long 3,3,3,3,3,3,3,3
109 .LONE_mont:
110 .quad 0x0000000000000001, 0xffffffff00000000, 0xffffffffffffffff, 0x00000000fffffffe
111 ___
112
113 {
114 ################################################################################
115 # void ecp_nistz256_mul_by_2(uint64_t res[4], uint64_t a[4]);
116
117 my ($a0,$a1,$a2,$a3)=map("%r$_",(8..11));
118 my ($t0,$t1,$t2,$t3,$t4)=("%rax","%rdx","%rcx","%r12","%r13");
119 my ($r_ptr,$a_ptr,$b_ptr)=("%rdi","%rsi","%rdx");
120
121 $code.=<<___;
122
123 .globl  ecp_nistz256_mul_by_2
124 .type   ecp_nistz256_mul_by_2,\@function,2
125 .align  64
126 ecp_nistz256_mul_by_2:
127         push    %r12
128         push    %r13
129
130         mov     8*0($a_ptr), $a0
131         mov     8*1($a_ptr), $a1
132         add     $a0, $a0                # a0:a3+a0:a3
133         mov     8*2($a_ptr), $a2
134         adc     $a1, $a1
135         mov     8*3($a_ptr), $a3
136         lea     .Lpoly(%rip), $a_ptr
137          mov    $a0, $t0
138         adc     $a2, $a2
139         adc     $a3, $a3
140          mov    $a1, $t1
141         sbb     $t4, $t4
142
143         sub     8*0($a_ptr), $a0
144          mov    $a2, $t2
145         sbb     8*1($a_ptr), $a1
146         sbb     8*2($a_ptr), $a2
147          mov    $a3, $t3
148         sbb     8*3($a_ptr), $a3
149         test    $t4, $t4
150
151         cmovz   $t0, $a0
152         cmovz   $t1, $a1
153         mov     $a0, 8*0($r_ptr)
154         cmovz   $t2, $a2
155         mov     $a1, 8*1($r_ptr)
156         cmovz   $t3, $a3
157         mov     $a2, 8*2($r_ptr)
158         mov     $a3, 8*3($r_ptr)
159
160         pop     %r13
161         pop     %r12
162         ret
163 .size   ecp_nistz256_mul_by_2,.-ecp_nistz256_mul_by_2
164
165 ################################################################################
166 # void ecp_nistz256_div_by_2(uint64_t res[4], uint64_t a[4]);
167 .globl  ecp_nistz256_div_by_2
168 .type   ecp_nistz256_div_by_2,\@function,2
169 .align  32
170 ecp_nistz256_div_by_2:
171         push    %r12
172         push    %r13
173
174         mov     8*0($a_ptr), $a0
175         mov     8*1($a_ptr), $a1
176         mov     8*2($a_ptr), $a2
177          mov    $a0, $t0
178         mov     8*3($a_ptr), $a3
179         lea     .Lpoly(%rip), $a_ptr
180
181          mov    $a1, $t1
182         xor     $t4, $t4
183         add     8*0($a_ptr), $a0
184          mov    $a2, $t2
185         adc     8*1($a_ptr), $a1
186         adc     8*2($a_ptr), $a2
187          mov    $a3, $t3
188         adc     8*3($a_ptr), $a3
189         adc     \$0, $t4
190         xor     $a_ptr, $a_ptr          # borrow $a_ptr
191         test    \$1, $t0
192
193         cmovz   $t0, $a0
194         cmovz   $t1, $a1
195         cmovz   $t2, $a2
196         cmovz   $t3, $a3
197         cmovz   $a_ptr, $t4
198
199         mov     $a1, $t0                # a0:a3>>1
200         shr     \$1, $a0
201         shl     \$63, $t0
202         mov     $a2, $t1
203         shr     \$1, $a1
204         or      $t0, $a0
205         shl     \$63, $t1
206         mov     $a3, $t2
207         shr     \$1, $a2
208         or      $t1, $a1
209         shl     \$63, $t2
210         shr     \$1, $a3
211         shl     \$63, $t4
212         or      $t2, $a2
213         or      $t4, $a3
214
215         mov     $a0, 8*0($r_ptr)
216         mov     $a1, 8*1($r_ptr)
217         mov     $a2, 8*2($r_ptr)
218         mov     $a3, 8*3($r_ptr)
219
220         pop     %r13
221         pop     %r12
222         ret
223 .size   ecp_nistz256_div_by_2,.-ecp_nistz256_div_by_2
224
225 ################################################################################
226 # void ecp_nistz256_mul_by_3(uint64_t res[4], uint64_t a[4]);
227 .globl  ecp_nistz256_mul_by_3
228 .type   ecp_nistz256_mul_by_3,\@function,2
229 .align  32
230 ecp_nistz256_mul_by_3:
231         push    %r12
232         push    %r13
233
234         mov     8*0($a_ptr), $a0
235         xor     $t4, $t4
236         mov     8*1($a_ptr), $a1
237         add     $a0, $a0                # a0:a3+a0:a3
238         mov     8*2($a_ptr), $a2
239         adc     $a1, $a1
240         mov     8*3($a_ptr), $a3
241          mov    $a0, $t0
242         adc     $a2, $a2
243         adc     $a3, $a3
244          mov    $a1, $t1
245         adc     \$0, $t4
246
247         sub     \$-1, $a0
248          mov    $a2, $t2
249         sbb     .Lpoly+8*1(%rip), $a1
250         sbb     \$0, $a2
251          mov    $a3, $t3
252         sbb     .Lpoly+8*3(%rip), $a3
253         test    $t4, $t4
254
255         cmovz   $t0, $a0
256         cmovz   $t1, $a1
257         cmovz   $t2, $a2
258         cmovz   $t3, $a3
259
260         xor     $t4, $t4
261         add     8*0($a_ptr), $a0        # a0:a3+=a_ptr[0:3]
262         adc     8*1($a_ptr), $a1
263          mov    $a0, $t0
264         adc     8*2($a_ptr), $a2
265         adc     8*3($a_ptr), $a3
266          mov    $a1, $t1
267         adc     \$0, $t4
268
269         sub     \$-1, $a0
270          mov    $a2, $t2
271         sbb     .Lpoly+8*1(%rip), $a1
272         sbb     \$0, $a2
273          mov    $a3, $t3
274         sbb     .Lpoly+8*3(%rip), $a3
275         test    $t4, $t4
276
277         cmovz   $t0, $a0
278         cmovz   $t1, $a1
279         mov     $a0, 8*0($r_ptr)
280         cmovz   $t2, $a2
281         mov     $a1, 8*1($r_ptr)
282         cmovz   $t3, $a3
283         mov     $a2, 8*2($r_ptr)
284         mov     $a3, 8*3($r_ptr)
285
286         pop %r13
287         pop %r12
288         ret
289 .size   ecp_nistz256_mul_by_3,.-ecp_nistz256_mul_by_3
290
291 ################################################################################
292 # void ecp_nistz256_add(uint64_t res[4], uint64_t a[4], uint64_t b[4]);
293 .globl  ecp_nistz256_add
294 .type   ecp_nistz256_add,\@function,3
295 .align  32
296 ecp_nistz256_add:
297         push    %r12
298         push    %r13
299
300         mov     8*0($a_ptr), $a0
301         xor     $t4, $t4
302         mov     8*1($a_ptr), $a1
303         mov     8*2($a_ptr), $a2
304         mov     8*3($a_ptr), $a3
305         lea     .Lpoly(%rip), $a_ptr
306
307         add     8*0($b_ptr), $a0
308         adc     8*1($b_ptr), $a1
309          mov    $a0, $t0
310         adc     8*2($b_ptr), $a2
311         adc     8*3($b_ptr), $a3
312          mov    $a1, $t1
313         adc     \$0, $t4
314
315         sub     8*0($a_ptr), $a0
316          mov    $a2, $t2
317         sbb     8*1($a_ptr), $a1
318         sbb     8*2($a_ptr), $a2
319          mov    $a3, $t3
320         sbb     8*3($a_ptr), $a3
321         test    $t4, $t4
322
323         cmovz   $t0, $a0
324         cmovz   $t1, $a1
325         mov     $a0, 8*0($r_ptr)
326         cmovz   $t2, $a2
327         mov     $a1, 8*1($r_ptr)
328         cmovz   $t3, $a3
329         mov     $a2, 8*2($r_ptr)
330         mov     $a3, 8*3($r_ptr)
331
332         pop %r13
333         pop %r12
334         ret
335 .size   ecp_nistz256_add,.-ecp_nistz256_add
336
337 ################################################################################
338 # void ecp_nistz256_sub(uint64_t res[4], uint64_t a[4], uint64_t b[4]);
339 .globl  ecp_nistz256_sub
340 .type   ecp_nistz256_sub,\@function,3
341 .align  32
342 ecp_nistz256_sub:
343         push    %r12
344         push    %r13
345
346         mov     8*0($a_ptr), $a0
347         xor     $t4, $t4
348         mov     8*1($a_ptr), $a1
349         mov     8*2($a_ptr), $a2
350         mov     8*3($a_ptr), $a3
351         lea     .Lpoly(%rip), $a_ptr
352
353         sub     8*0($b_ptr), $a0
354         sbb     8*1($b_ptr), $a1
355          mov    $a0, $t0
356         sbb     8*2($b_ptr), $a2
357         sbb     8*3($b_ptr), $a3
358          mov    $a1, $t1
359         sbb     \$0, $t4
360
361         add     8*0($a_ptr), $a0
362          mov    $a2, $t2
363         adc     8*1($a_ptr), $a1
364         adc     8*2($a_ptr), $a2
365          mov    $a3, $t3
366         adc     8*3($a_ptr), $a3
367         test    $t4, $t4
368
369         cmovz   $t0, $a0
370         cmovz   $t1, $a1
371         mov     $a0, 8*0($r_ptr)
372         cmovz   $t2, $a2
373         mov     $a1, 8*1($r_ptr)
374         cmovz   $t3, $a3
375         mov     $a2, 8*2($r_ptr)
376         mov     $a3, 8*3($r_ptr)
377
378         pop %r13
379         pop %r12
380         ret
381 .size   ecp_nistz256_sub,.-ecp_nistz256_sub
382
383 ################################################################################
384 # void ecp_nistz256_neg(uint64_t res[4], uint64_t a[4]);
385 .globl  ecp_nistz256_neg
386 .type   ecp_nistz256_neg,\@function,2
387 .align  32
388 ecp_nistz256_neg:
389         push    %r12
390         push    %r13
391
392         xor     $a0, $a0
393         xor     $a1, $a1
394         xor     $a2, $a2
395         xor     $a3, $a3
396         xor     $t4, $t4
397
398         sub     8*0($a_ptr), $a0
399         sbb     8*1($a_ptr), $a1
400         sbb     8*2($a_ptr), $a2
401          mov    $a0, $t0
402         sbb     8*3($a_ptr), $a3
403         lea     .Lpoly(%rip), $a_ptr
404          mov    $a1, $t1
405         sbb     \$0, $t4
406
407         add     8*0($a_ptr), $a0
408          mov    $a2, $t2
409         adc     8*1($a_ptr), $a1
410         adc     8*2($a_ptr), $a2
411          mov    $a3, $t3
412         adc     8*3($a_ptr), $a3
413         test    $t4, $t4
414
415         cmovz   $t0, $a0
416         cmovz   $t1, $a1
417         mov     $a0, 8*0($r_ptr)
418         cmovz   $t2, $a2
419         mov     $a1, 8*1($r_ptr)
420         cmovz   $t3, $a3
421         mov     $a2, 8*2($r_ptr)
422         mov     $a3, 8*3($r_ptr)
423
424         pop %r13
425         pop %r12
426         ret
427 .size   ecp_nistz256_neg,.-ecp_nistz256_neg
428 ___
429 }
430 {
431 my ($r_ptr,$a_ptr,$b_org,$b_ptr)=("%rdi","%rsi","%rdx","%rbx");
432 my ($acc0,$acc1,$acc2,$acc3,$acc4,$acc5,$acc6,$acc7)=map("%r$_",(8..15));
433 my ($t0,$t1,$t2,$t3,$t4)=("%rcx","%rbp","%rbx","%rdx","%rax");
434 my ($poly1,$poly3)=($acc6,$acc7);
435
436 $code.=<<___;
437 ################################################################################
438 # void ecp_nistz256_to_mont(
439 #   uint64_t res[4],
440 #   uint64_t in[4]);
441 .globl  ecp_nistz256_to_mont
442 .type   ecp_nistz256_to_mont,\@function,2
443 .align  32
444 ecp_nistz256_to_mont:
445 ___
446 $code.=<<___    if ($addx);
447         mov     \$0x80100, %ecx
448         and     OPENSSL_ia32cap_P+8(%rip), %ecx
449 ___
450 $code.=<<___;
451         lea     .LRR(%rip), $b_org
452         jmp     .Lmul_mont
453 .size   ecp_nistz256_to_mont,.-ecp_nistz256_to_mont
454
455 ################################################################################
456 # void ecp_nistz256_mul_mont(
457 #   uint64_t res[4],
458 #   uint64_t a[4],
459 #   uint64_t b[4]);
460
461 .globl  ecp_nistz256_mul_mont
462 .type   ecp_nistz256_mul_mont,\@function,3
463 .align  32
464 ecp_nistz256_mul_mont:
465 ___
466 $code.=<<___    if ($addx);
467         mov     \$0x80100, %ecx
468         and     OPENSSL_ia32cap_P+8(%rip), %ecx
469 ___
470 $code.=<<___;
471 .Lmul_mont:
472         push    %rbp
473         push    %rbx
474         push    %r12
475         push    %r13
476         push    %r14
477         push    %r15
478 ___
479 $code.=<<___    if ($addx);
480         cmp     \$0x80100, %ecx
481         je      .Lmul_montx
482 ___
483 $code.=<<___;
484         mov     $b_org, $b_ptr
485         mov     8*0($b_org), %rax
486         mov     8*0($a_ptr), $acc1
487         mov     8*1($a_ptr), $acc2
488         mov     8*2($a_ptr), $acc3
489         mov     8*3($a_ptr), $acc4
490
491         call    __ecp_nistz256_mul_montq
492 ___
493 $code.=<<___    if ($addx);
494         jmp     .Lmul_mont_done
495
496 .align  32
497 .Lmul_montx:
498         mov     $b_org, $b_ptr
499         mov     8*0($b_org), %rdx
500         mov     8*0($a_ptr), $acc1
501         mov     8*1($a_ptr), $acc2
502         mov     8*2($a_ptr), $acc3
503         mov     8*3($a_ptr), $acc4
504         lea     -128($a_ptr), $a_ptr    # control u-op density
505
506         call    __ecp_nistz256_mul_montx
507 ___
508 $code.=<<___;
509 .Lmul_mont_done:
510         pop     %r15
511         pop     %r14
512         pop     %r13
513         pop     %r12
514         pop     %rbx
515         pop     %rbp
516         ret
517 .size   ecp_nistz256_mul_mont,.-ecp_nistz256_mul_mont
518
519 .type   __ecp_nistz256_mul_montq,\@abi-omnipotent
520 .align  32
521 __ecp_nistz256_mul_montq:
522         ########################################################################
523         # Multiply a by b[0]
524         mov     %rax, $t1
525         mulq    $acc1
526         mov     .Lpoly+8*1(%rip),$poly1
527         mov     %rax, $acc0
528         mov     $t1, %rax
529         mov     %rdx, $acc1
530
531         mulq    $acc2
532         mov     .Lpoly+8*3(%rip),$poly3
533         add     %rax, $acc1
534         mov     $t1, %rax
535         adc     \$0, %rdx
536         mov     %rdx, $acc2
537
538         mulq    $acc3
539         add     %rax, $acc2
540         mov     $t1, %rax
541         adc     \$0, %rdx
542         mov     %rdx, $acc3
543
544         mulq    $acc4
545         add     %rax, $acc3
546          mov    $acc0, %rax
547         adc     \$0, %rdx
548         xor     $acc5, $acc5
549         mov     %rdx, $acc4
550
551         ########################################################################
552         # First reduction step
553         # Basically now we want to multiply acc[0] by p256,
554         # and add the result to the acc.
555         # Due to the special form of p256 we do some optimizations
556         #
557         # acc[0] x p256[0..1] = acc[0] x 2^96 - acc[0]
558         # then we add acc[0] and get acc[0] x 2^96
559
560         mov     $acc0, $t1
561         shl     \$32, $acc0
562         mulq    $poly3
563         shr     \$32, $t1
564         add     $acc0, $acc1            # +=acc[0]<<96
565         adc     $t1, $acc2
566         adc     %rax, $acc3
567          mov    8*1($b_ptr), %rax
568         adc     %rdx, $acc4
569         adc     \$0, $acc5
570         xor     $acc0, $acc0
571
572         ########################################################################
573         # Multiply by b[1]
574         mov     %rax, $t1
575         mulq    8*0($a_ptr)
576         add     %rax, $acc1
577         mov     $t1, %rax
578         adc     \$0, %rdx
579         mov     %rdx, $t0
580
581         mulq    8*1($a_ptr)
582         add     $t0, $acc2
583         adc     \$0, %rdx
584         add     %rax, $acc2
585         mov     $t1, %rax
586         adc     \$0, %rdx
587         mov     %rdx, $t0
588
589         mulq    8*2($a_ptr)
590         add     $t0, $acc3
591         adc     \$0, %rdx
592         add     %rax, $acc3
593         mov     $t1, %rax
594         adc     \$0, %rdx
595         mov     %rdx, $t0
596
597         mulq    8*3($a_ptr)
598         add     $t0, $acc4
599         adc     \$0, %rdx
600         add     %rax, $acc4
601          mov    $acc1, %rax
602         adc     %rdx, $acc5
603         adc     \$0, $acc0
604
605         ########################################################################
606         # Second reduction step 
607         mov     $acc1, $t1
608         shl     \$32, $acc1
609         mulq    $poly3
610         shr     \$32, $t1
611         add     $acc1, $acc2
612         adc     $t1, $acc3
613         adc     %rax, $acc4
614          mov    8*2($b_ptr), %rax
615         adc     %rdx, $acc5
616         adc     \$0, $acc0
617         xor     $acc1, $acc1
618
619         ########################################################################
620         # Multiply by b[2]
621         mov     %rax, $t1
622         mulq    8*0($a_ptr)
623         add     %rax, $acc2
624         mov     $t1, %rax
625         adc     \$0, %rdx
626         mov     %rdx, $t0
627
628         mulq    8*1($a_ptr)
629         add     $t0, $acc3
630         adc     \$0, %rdx
631         add     %rax, $acc3
632         mov     $t1, %rax
633         adc     \$0, %rdx
634         mov     %rdx, $t0
635
636         mulq    8*2($a_ptr)
637         add     $t0, $acc4
638         adc     \$0, %rdx
639         add     %rax, $acc4
640         mov     $t1, %rax
641         adc     \$0, %rdx
642         mov     %rdx, $t0
643
644         mulq    8*3($a_ptr)
645         add     $t0, $acc5
646         adc     \$0, %rdx
647         add     %rax, $acc5
648          mov    $acc2, %rax
649         adc     %rdx, $acc0
650         adc     \$0, $acc1
651
652         ########################################################################
653         # Third reduction step  
654         mov     $acc2, $t1
655         shl     \$32, $acc2
656         mulq    $poly3
657         shr     \$32, $t1
658         add     $acc2, $acc3
659         adc     $t1, $acc4
660         adc     %rax, $acc5
661          mov    8*3($b_ptr), %rax
662         adc     %rdx, $acc0
663         adc     \$0, $acc1
664         xor     $acc2, $acc2
665
666         ########################################################################
667         # Multiply by b[3]
668         mov     %rax, $t1
669         mulq    8*0($a_ptr)
670         add     %rax, $acc3
671         mov     $t1, %rax
672         adc     \$0, %rdx
673         mov     %rdx, $t0
674
675         mulq    8*1($a_ptr)
676         add     $t0, $acc4
677         adc     \$0, %rdx
678         add     %rax, $acc4
679         mov     $t1, %rax
680         adc     \$0, %rdx
681         mov     %rdx, $t0
682
683         mulq    8*2($a_ptr)
684         add     $t0, $acc5
685         adc     \$0, %rdx
686         add     %rax, $acc5
687         mov     $t1, %rax
688         adc     \$0, %rdx
689         mov     %rdx, $t0
690
691         mulq    8*3($a_ptr)
692         add     $t0, $acc0
693         adc     \$0, %rdx
694         add     %rax, $acc0
695          mov    $acc3, %rax
696         adc     %rdx, $acc1
697         adc     \$0, $acc2
698
699         ########################################################################
700         # Final reduction step  
701         mov     $acc3, $t1
702         shl     \$32, $acc3
703         mulq    $poly3
704         shr     \$32, $t1
705         add     $acc3, $acc4
706         adc     $t1, $acc5
707          mov    $acc4, $t0
708         adc     %rax, $acc0
709         adc     %rdx, $acc1
710          mov    $acc5, $t1
711         adc     \$0, $acc2
712
713         ########################################################################        
714         # Branch-less conditional subtraction of P
715         sub     \$-1, $acc4             # .Lpoly[0]
716          mov    $acc0, $t2
717         sbb     $poly1, $acc5           # .Lpoly[1]
718         sbb     \$0, $acc0              # .Lpoly[2]
719          mov    $acc1, $t3
720         sbb     $poly3, $acc1           # .Lpoly[3]
721         sbb     \$0, $acc2
722
723         cmovc   $t0, $acc4
724         cmovc   $t1, $acc5
725         mov     $acc4, 8*0($r_ptr)
726         cmovc   $t2, $acc0
727         mov     $acc5, 8*1($r_ptr)
728         cmovc   $t3, $acc1
729         mov     $acc0, 8*2($r_ptr)
730         mov     $acc1, 8*3($r_ptr)
731
732         ret
733 .size   __ecp_nistz256_mul_montq,.-__ecp_nistz256_mul_montq
734
735 ################################################################################
736 # void ecp_nistz256_sqr_mont(
737 #   uint64_t res[4],
738 #   uint64_t a[4]);
739
740 # we optimize the square according to S.Gueron and V.Krasnov,
741 # "Speeding up Big-Number Squaring"
742 .globl  ecp_nistz256_sqr_mont
743 .type   ecp_nistz256_sqr_mont,\@function,2
744 .align  32
745 ecp_nistz256_sqr_mont:
746 ___
747 $code.=<<___    if ($addx);
748         mov     \$0x80100, %ecx
749         and     OPENSSL_ia32cap_P+8(%rip), %ecx
750 ___
751 $code.=<<___;
752         push    %rbp
753         push    %rbx
754         push    %r12
755         push    %r13
756         push    %r14
757         push    %r15
758 ___
759 $code.=<<___    if ($addx);
760         cmp     \$0x80100, %ecx
761         je      .Lsqr_montx
762 ___
763 $code.=<<___;
764         mov     8*0($a_ptr), %rax
765         mov     8*1($a_ptr), $acc6
766         mov     8*2($a_ptr), $acc7
767         mov     8*3($a_ptr), $acc0
768
769         call    __ecp_nistz256_sqr_montq
770 ___
771 $code.=<<___    if ($addx);
772         jmp     .Lsqr_mont_done
773
774 .align  32
775 .Lsqr_montx:
776         mov     8*0($a_ptr), %rdx
777         mov     8*1($a_ptr), $acc6
778         mov     8*2($a_ptr), $acc7
779         mov     8*3($a_ptr), $acc0
780         lea     -128($a_ptr), $a_ptr    # control u-op density
781
782         call    __ecp_nistz256_sqr_montx
783 ___
784 $code.=<<___;
785 .Lsqr_mont_done:
786         pop     %r15
787         pop     %r14
788         pop     %r13
789         pop     %r12
790         pop     %rbx
791         pop     %rbp
792         ret
793 .size   ecp_nistz256_sqr_mont,.-ecp_nistz256_sqr_mont
794
795 .type   __ecp_nistz256_sqr_montq,\@abi-omnipotent
796 .align  32
797 __ecp_nistz256_sqr_montq:
798         mov     %rax, $acc5
799         mulq    $acc6                   # a[1]*a[0]
800         mov     %rax, $acc1
801         mov     $acc7, %rax
802         mov     %rdx, $acc2
803
804         mulq    $acc5                   # a[0]*a[2]
805         add     %rax, $acc2
806         mov     $acc0, %rax
807         adc     \$0, %rdx
808         mov     %rdx, $acc3
809
810         mulq    $acc5                   # a[0]*a[3]
811         add     %rax, $acc3
812          mov    $acc7, %rax
813         adc     \$0, %rdx
814         mov     %rdx, $acc4
815
816         #################################
817         mulq    $acc6                   # a[1]*a[2]
818         add     %rax, $acc3
819         mov     $acc0, %rax
820         adc     \$0, %rdx
821         mov     %rdx, $t1
822
823         mulq    $acc6                   # a[1]*a[3]
824         add     %rax, $acc4
825          mov    $acc0, %rax
826         adc     \$0, %rdx
827         add     $t1, $acc4
828         mov     %rdx, $acc5
829         adc     \$0, $acc5
830
831         #################################
832         mulq    $acc7                   # a[2]*a[3]
833         xor     $acc7, $acc7
834         add     %rax, $acc5
835          mov    8*0($a_ptr), %rax
836         mov     %rdx, $acc6
837         adc     \$0, $acc6
838
839         add     $acc1, $acc1            # acc1:6<<1
840         adc     $acc2, $acc2
841         adc     $acc3, $acc3
842         adc     $acc4, $acc4
843         adc     $acc5, $acc5
844         adc     $acc6, $acc6
845         adc     \$0, $acc7
846
847         mulq    %rax
848         mov     %rax, $acc0
849         mov     8*1($a_ptr), %rax
850         mov     %rdx, $t0
851
852         mulq    %rax
853         add     $t0, $acc1
854         adc     %rax, $acc2
855         mov     8*2($a_ptr), %rax
856         adc     \$0, %rdx
857         mov     %rdx, $t0
858
859         mulq    %rax
860         add     $t0, $acc3
861         adc     %rax, $acc4
862         mov     8*3($a_ptr), %rax
863         adc     \$0, %rdx
864         mov     %rdx, $t0
865
866         mulq    %rax
867         add     $t0, $acc5
868         adc     %rax, $acc6
869          mov    $acc0, %rax
870         adc     %rdx, $acc7
871
872         mov     .Lpoly+8*1(%rip), $a_ptr
873         mov     .Lpoly+8*3(%rip), $t1
874
875         ##########################################
876         # Now the reduction
877         # First iteration
878         mov     $acc0, $t0
879         shl     \$32, $acc0
880         mulq    $t1
881         shr     \$32, $t0
882         add     $acc0, $acc1            # +=acc[0]<<96
883         adc     $t0, $acc2
884         adc     %rax, $acc3
885          mov    $acc1, %rax
886         adc     \$0, %rdx
887
888         ##########################################
889         # Second iteration
890         mov     $acc1, $t0
891         shl     \$32, $acc1
892         mov     %rdx, $acc0
893         mulq    $t1
894         shr     \$32, $t0
895         add     $acc1, $acc2
896         adc     $t0, $acc3
897         adc     %rax, $acc0
898          mov    $acc2, %rax
899         adc     \$0, %rdx
900
901         ##########################################
902         # Third iteration
903         mov     $acc2, $t0
904         shl     \$32, $acc2
905         mov     %rdx, $acc1
906         mulq    $t1
907         shr     \$32, $t0
908         add     $acc2, $acc3
909         adc     $t0, $acc0
910         adc     %rax, $acc1
911          mov    $acc3, %rax
912         adc     \$0, %rdx
913
914         ###########################################
915         # Last iteration
916         mov     $acc3, $t0
917         shl     \$32, $acc3
918         mov     %rdx, $acc2
919         mulq    $t1
920         shr     \$32, $t0
921         add     $acc3, $acc0
922         adc     $t0, $acc1
923         adc     %rax, $acc2
924         adc     \$0, %rdx
925         xor     $acc3, $acc3
926
927         ############################################
928         # Add the rest of the acc
929         add     $acc0, $acc4
930         adc     $acc1, $acc5
931          mov    $acc4, $acc0
932         adc     $acc2, $acc6
933         adc     %rdx, $acc7
934          mov    $acc5, $acc1
935         adc     \$0, $acc3
936
937         sub     \$-1, $acc4             # .Lpoly[0]
938          mov    $acc6, $acc2
939         sbb     $a_ptr, $acc5           # .Lpoly[1]
940         sbb     \$0, $acc6              # .Lpoly[2]
941          mov    $acc7, $t0
942         sbb     $t1, $acc7              # .Lpoly[3]
943         sbb     \$0, $acc3
944
945         cmovc   $acc0, $acc4
946         cmovc   $acc1, $acc5
947         mov     $acc4, 8*0($r_ptr)
948         cmovc   $acc2, $acc6
949         mov     $acc5, 8*1($r_ptr)
950         cmovc   $t0, $acc7
951         mov     $acc6, 8*2($r_ptr)
952         mov     $acc7, 8*3($r_ptr)
953
954         ret
955 .size   __ecp_nistz256_sqr_montq,.-__ecp_nistz256_sqr_montq
956 ___
957
958 if ($addx) {
959 $code.=<<___;
960 .type   __ecp_nistz256_mul_montx,\@abi-omnipotent
961 .align  32
962 __ecp_nistz256_mul_montx:
963         ########################################################################
964         # Multiply by b[0]
965         mulx    $acc1, $acc0, $acc1
966         mulx    $acc2, $t0, $acc2
967         mov     \$32, $poly1
968         xor     $acc5, $acc5            # cf=0
969         mulx    $acc3, $t1, $acc3
970         mov     .Lpoly+8*3(%rip), $poly3
971         adc     $t0, $acc1
972         mulx    $acc4, $t0, $acc4
973          mov    $acc0, %rdx
974         adc     $t1, $acc2
975          shlx   $poly1,$acc0,$t1
976         adc     $t0, $acc3
977          shrx   $poly1,$acc0,$t0
978         adc     \$0, $acc4
979
980         ########################################################################
981         # First reduction step
982         add     $t1, $acc1
983         adc     $t0, $acc2
984
985         mulx    $poly3, $t0, $t1
986          mov    8*1($b_ptr), %rdx
987         adc     $t0, $acc3
988         adc     $t1, $acc4
989         adc     \$0, $acc5
990         xor     $acc0, $acc0            # $acc0=0,cf=0,of=0
991
992         ########################################################################
993         # Multiply by b[1]
994         mulx    8*0+128($a_ptr), $t0, $t1
995         adcx    $t0, $acc1
996         adox    $t1, $acc2
997
998         mulx    8*1+128($a_ptr), $t0, $t1
999         adcx    $t0, $acc2
1000         adox    $t1, $acc3
1001
1002         mulx    8*2+128($a_ptr), $t0, $t1
1003         adcx    $t0, $acc3
1004         adox    $t1, $acc4
1005
1006         mulx    8*3+128($a_ptr), $t0, $t1
1007          mov    $acc1, %rdx
1008         adcx    $t0, $acc4
1009          shlx   $poly1, $acc1, $t0
1010         adox    $t1, $acc5
1011          shrx   $poly1, $acc1, $t1
1012
1013         adcx    $acc0, $acc5
1014         adox    $acc0, $acc0
1015         adc     \$0, $acc0
1016
1017         ########################################################################
1018         # Second reduction step
1019         add     $t0, $acc2
1020         adc     $t1, $acc3
1021
1022         mulx    $poly3, $t0, $t1
1023          mov    8*2($b_ptr), %rdx
1024         adc     $t0, $acc4
1025         adc     $t1, $acc5
1026         adc     \$0, $acc0
1027         xor     $acc1 ,$acc1            # $acc1=0,cf=0,of=0
1028
1029         ########################################################################
1030         # Multiply by b[2]
1031         mulx    8*0+128($a_ptr), $t0, $t1
1032         adcx    $t0, $acc2
1033         adox    $t1, $acc3
1034
1035         mulx    8*1+128($a_ptr), $t0, $t1
1036         adcx    $t0, $acc3
1037         adox    $t1, $acc4
1038
1039         mulx    8*2+128($a_ptr), $t0, $t1
1040         adcx    $t0, $acc4
1041         adox    $t1, $acc5
1042
1043         mulx    8*3+128($a_ptr), $t0, $t1
1044          mov    $acc2, %rdx
1045         adcx    $t0, $acc5
1046          shlx   $poly1, $acc2, $t0
1047         adox    $t1, $acc0
1048          shrx   $poly1, $acc2, $t1
1049
1050         adcx    $acc1, $acc0
1051         adox    $acc1, $acc1
1052         adc     \$0, $acc1
1053
1054         ########################################################################
1055         # Third reduction step
1056         add     $t0, $acc3
1057         adc     $t1, $acc4
1058
1059         mulx    $poly3, $t0, $t1
1060          mov    8*3($b_ptr), %rdx
1061         adc     $t0, $acc5
1062         adc     $t1, $acc0
1063         adc     \$0, $acc1
1064         xor     $acc2, $acc2            # $acc2=0,cf=0,of=0
1065
1066         ########################################################################
1067         # Multiply by b[3]
1068         mulx    8*0+128($a_ptr), $t0, $t1
1069         adcx    $t0, $acc3
1070         adox    $t1, $acc4
1071
1072         mulx    8*1+128($a_ptr), $t0, $t1
1073         adcx    $t0, $acc4
1074         adox    $t1, $acc5
1075
1076         mulx    8*2+128($a_ptr), $t0, $t1
1077         adcx    $t0, $acc5
1078         adox    $t1, $acc0
1079
1080         mulx    8*3+128($a_ptr), $t0, $t1
1081          mov    $acc3, %rdx
1082         adcx    $t0, $acc0
1083          shlx   $poly1, $acc3, $t0
1084         adox    $t1, $acc1
1085          shrx   $poly1, $acc3, $t1
1086
1087         adcx    $acc2, $acc1
1088         adox    $acc2, $acc2
1089         adc     \$0, $acc2
1090
1091         ########################################################################
1092         # Fourth reduction step
1093         add     $t0, $acc4
1094         adc     $t1, $acc5
1095
1096         mulx    $poly3, $t0, $t1
1097          mov    $acc4, $t2
1098         mov     .Lpoly+8*1(%rip), $poly1
1099         adc     $t0, $acc0
1100          mov    $acc5, $t3
1101         adc     $t1, $acc1
1102         adc     \$0, $acc2
1103
1104         ########################################################################
1105         # Branch-less conditional subtraction of P
1106         xor     %eax, %eax
1107          mov    $acc0, $t0
1108         sbb     \$-1, $acc4             # .Lpoly[0]
1109         sbb     $poly1, $acc5           # .Lpoly[1]
1110         sbb     \$0, $acc0              # .Lpoly[2]
1111          mov    $acc1, $t1
1112         sbb     $poly3, $acc1           # .Lpoly[3]
1113         sbb     \$0, $acc2
1114
1115         cmovc   $t2, $acc4
1116         cmovc   $t3, $acc5
1117         mov     $acc4, 8*0($r_ptr)
1118         cmovc   $t0, $acc0
1119         mov     $acc5, 8*1($r_ptr)
1120         cmovc   $t1, $acc1
1121         mov     $acc0, 8*2($r_ptr)
1122         mov     $acc1, 8*3($r_ptr)
1123
1124         ret
1125 .size   __ecp_nistz256_mul_montx,.-__ecp_nistz256_mul_montx
1126
1127 .type   __ecp_nistz256_sqr_montx,\@abi-omnipotent
1128 .align  32
1129 __ecp_nistz256_sqr_montx:
1130         mulx    $acc6, $acc1, $acc2     # a[0]*a[1]
1131         mulx    $acc7, $t0, $acc3       # a[0]*a[2]
1132         xor     %eax, %eax
1133         adc     $t0, $acc2
1134         mulx    $acc0, $t1, $acc4       # a[0]*a[3]
1135          mov    $acc6, %rdx
1136         adc     $t1, $acc3
1137         adc     \$0, $acc4
1138         xor     $acc5, $acc5            # $acc5=0,cf=0,of=0
1139
1140         #################################
1141         mulx    $acc7, $t0, $t1         # a[1]*a[2]
1142         adcx    $t0, $acc3
1143         adox    $t1, $acc4
1144
1145         mulx    $acc0, $t0, $t1         # a[1]*a[3]
1146          mov    $acc7, %rdx
1147         adcx    $t0, $acc4
1148         adox    $t1, $acc5
1149         adc     \$0, $acc5
1150
1151         #################################
1152         mulx    $acc0, $t0, $acc6       # a[2]*a[3]
1153          mov    8*0+128($a_ptr), %rdx
1154         xor     $acc7, $acc7            # $acc7=0,cf=0,of=0
1155          adcx   $acc1, $acc1            # acc1:6<<1
1156         adox    $t0, $acc5
1157          adcx   $acc2, $acc2
1158         adox    $acc7, $acc6            # of=0
1159
1160         mulx    %rdx, $acc0, $t1
1161         mov     8*1+128($a_ptr), %rdx
1162          adcx   $acc3, $acc3
1163         adox    $t1, $acc1
1164          adcx   $acc4, $acc4
1165         mulx    %rdx, $t0, $t4
1166         mov     8*2+128($a_ptr), %rdx
1167          adcx   $acc5, $acc5
1168         adox    $t0, $acc2
1169          adcx   $acc6, $acc6
1170         .byte   0x67
1171         mulx    %rdx, $t0, $t1
1172         mov     8*3+128($a_ptr), %rdx
1173         adox    $t4, $acc3
1174          adcx   $acc7, $acc7
1175         adox    $t0, $acc4
1176          mov    \$32, $a_ptr
1177         adox    $t1, $acc5
1178         .byte   0x67,0x67
1179         mulx    %rdx, $t0, $t4
1180          mov    $acc0, %rdx
1181         adox    $t0, $acc6
1182          shlx   $a_ptr, $acc0, $t0
1183         adox    $t4, $acc7
1184          shrx   $a_ptr, $acc0, $t4
1185          mov    .Lpoly+8*3(%rip), $t1
1186
1187         # reduction step 1
1188         add     $t0, $acc1
1189         adc     $t4, $acc2
1190
1191         mulx    $t1, $t0, $acc0
1192          mov    $acc1, %rdx
1193         adc     $t0, $acc3
1194          shlx   $a_ptr, $acc1, $t0
1195         adc     \$0, $acc0
1196          shrx   $a_ptr, $acc1, $t4
1197
1198         # reduction step 2
1199         add     $t0, $acc2
1200         adc     $t4, $acc3
1201
1202         mulx    $t1, $t0, $acc1
1203          mov    $acc2, %rdx
1204         adc     $t0, $acc0
1205          shlx   $a_ptr, $acc2, $t0
1206         adc     \$0, $acc1
1207          shrx   $a_ptr, $acc2, $t4
1208
1209         # reduction step 3
1210         add     $t0, $acc3
1211         adc     $t4, $acc0
1212
1213         mulx    $t1, $t0, $acc2
1214          mov    $acc3, %rdx
1215         adc     $t0, $acc1
1216          shlx   $a_ptr, $acc3, $t0
1217         adc     \$0, $acc2
1218          shrx   $a_ptr, $acc3, $t4
1219
1220         # reduction step 4
1221         add     $t0, $acc0
1222         adc     $t4, $acc1
1223
1224         mulx    $t1, $t0, $acc3
1225         adc     $t0, $acc2
1226         adc     \$0, $acc3
1227
1228         xor     $t3, $t3                # cf=0
1229         adc     $acc0, $acc4            # accumulate upper half
1230          mov    .Lpoly+8*1(%rip), $a_ptr
1231         adc     $acc1, $acc5
1232          mov    $acc4, $acc0
1233         adc     $acc2, $acc6
1234         adc     $acc3, $acc7
1235          mov    $acc5, $acc1
1236         adc     \$0, $t3
1237
1238         xor     %eax, %eax              # cf=0
1239         sbb     \$-1, $acc4             # .Lpoly[0]
1240          mov    $acc6, $acc2
1241         sbb     $a_ptr, $acc5           # .Lpoly[1]
1242         sbb     \$0, $acc6              # .Lpoly[2]
1243          mov    $acc7, $acc3
1244         sbb     $t1, $acc7              # .Lpoly[3]
1245         sbb     \$0, $t3
1246
1247         cmovc   $acc0, $acc4
1248         cmovc   $acc1, $acc5
1249         mov     $acc4, 8*0($r_ptr)
1250         cmovc   $acc2, $acc6
1251         mov     $acc5, 8*1($r_ptr)
1252         cmovc   $acc3, $acc7
1253         mov     $acc6, 8*2($r_ptr)
1254         mov     $acc7, 8*3($r_ptr)
1255
1256         ret
1257 .size   __ecp_nistz256_sqr_montx,.-__ecp_nistz256_sqr_montx
1258 ___
1259 }
1260 }
1261 {
1262 my ($r_ptr,$in_ptr)=("%rdi","%rsi");
1263 my ($acc0,$acc1,$acc2,$acc3)=map("%r$_",(8..11));
1264 my ($t0,$t1,$t2)=("%rcx","%r12","%r13");
1265
1266 $code.=<<___;
1267 ################################################################################
1268 # void ecp_nistz256_from_mont(
1269 #   uint64_t res[4],
1270 #   uint64_t in[4]);
1271 # This one performs Montgomery multiplication by 1, so we only need the reduction
1272
1273 .globl  ecp_nistz256_from_mont
1274 .type   ecp_nistz256_from_mont,\@function,2
1275 .align  32
1276 ecp_nistz256_from_mont:
1277         push    %r12
1278         push    %r13
1279
1280         mov     8*0($in_ptr), %rax
1281         mov     .Lpoly+8*3(%rip), $t2
1282         mov     8*1($in_ptr), $acc1
1283         mov     8*2($in_ptr), $acc2
1284         mov     8*3($in_ptr), $acc3
1285         mov     %rax, $acc0
1286         mov     .Lpoly+8*1(%rip), $t1
1287
1288         #########################################
1289         # First iteration
1290         mov     %rax, $t0
1291         shl     \$32, $acc0
1292         mulq    $t2
1293         shr     \$32, $t0
1294         add     $acc0, $acc1
1295         adc     $t0, $acc2
1296         adc     %rax, $acc3
1297          mov    $acc1, %rax
1298         adc     \$0, %rdx
1299
1300         #########################################
1301         # Second iteration
1302         mov     $acc1, $t0
1303         shl     \$32, $acc1
1304         mov     %rdx, $acc0
1305         mulq    $t2
1306         shr     \$32, $t0
1307         add     $acc1, $acc2
1308         adc     $t0, $acc3
1309         adc     %rax, $acc0
1310          mov    $acc2, %rax
1311         adc     \$0, %rdx
1312
1313         ##########################################
1314         # Third iteration
1315         mov     $acc2, $t0
1316         shl     \$32, $acc2
1317         mov     %rdx, $acc1
1318         mulq    $t2
1319         shr     \$32, $t0
1320         add     $acc2, $acc3
1321         adc     $t0, $acc0
1322         adc     %rax, $acc1
1323          mov    $acc3, %rax
1324         adc     \$0, %rdx
1325
1326         ###########################################
1327         # Last iteration
1328         mov     $acc3, $t0
1329         shl     \$32, $acc3
1330         mov     %rdx, $acc2
1331         mulq    $t2
1332         shr     \$32, $t0
1333         add     $acc3, $acc0
1334         adc     $t0, $acc1
1335          mov    $acc0, $t0
1336         adc     %rax, $acc2
1337          mov    $acc1, $in_ptr
1338         adc     \$0, %rdx
1339
1340         ###########################################
1341         # Branch-less conditional subtraction
1342         sub     \$-1, $acc0
1343          mov    $acc2, %rax
1344         sbb     $t1, $acc1
1345         sbb     \$0, $acc2
1346          mov    %rdx, $acc3
1347         sbb     $t2, %rdx
1348         sbb     $t2, $t2
1349
1350         cmovnz  $t0, $acc0
1351         cmovnz  $in_ptr, $acc1
1352         mov     $acc0, 8*0($r_ptr)
1353         cmovnz  %rax, $acc2
1354         mov     $acc1, 8*1($r_ptr)
1355         cmovz   %rdx, $acc3
1356         mov     $acc2, 8*2($r_ptr)
1357         mov     $acc3, 8*3($r_ptr)
1358
1359         pop     %r13
1360         pop     %r12
1361         ret
1362 .size   ecp_nistz256_from_mont,.-ecp_nistz256_from_mont
1363 ___
1364 }
1365 {
1366 my ($val,$in_t,$index)=$win64?("%rcx","%rdx","%r8d"):("%rdi","%rsi","%edx");
1367 my ($ONE,$INDEX,$Ra,$Rb,$Rc,$Rd,$Re,$Rf)=map("%xmm$_",(0..7));
1368 my ($M0,$T0a,$T0b,$T0c,$T0d,$T0e,$T0f,$TMP0)=map("%xmm$_",(8..15));
1369 my ($M1,$T2a,$T2b,$TMP2,$M2,$T2a,$T2b,$TMP2)=map("%xmm$_",(8..15));
1370
1371 $code.=<<___;
1372 ################################################################################
1373 # void ecp_nistz256_scatter_w5(uint64_t *val, uint64_t *in_t, int index);
1374 .globl  ecp_nistz256_scatter_w5
1375 .type   ecp_nistz256_scatter_w5,\@abi-omnipotent
1376 .align  32
1377 ecp_nistz256_scatter_w5:
1378         lea     -3($index,$index,2), $index
1379         movdqa  0x00($in_t), %xmm0
1380         shl     \$5, $index
1381         movdqa  0x10($in_t), %xmm1
1382         movdqa  0x20($in_t), %xmm2
1383         movdqa  0x30($in_t), %xmm3
1384         movdqa  0x40($in_t), %xmm4
1385         movdqa  0x50($in_t), %xmm5
1386         movdqa  %xmm0, 0x00($val,$index)
1387         movdqa  %xmm1, 0x10($val,$index)
1388         movdqa  %xmm2, 0x20($val,$index)
1389         movdqa  %xmm3, 0x30($val,$index)
1390         movdqa  %xmm4, 0x40($val,$index)
1391         movdqa  %xmm5, 0x50($val,$index)
1392
1393         ret
1394 .size   ecp_nistz256_scatter_w5,.-ecp_nistz256_scatter_w5
1395
1396 ################################################################################
1397 # void ecp_nistz256_gather_w5(uint64_t *val, uint64_t *in_t, int index);
1398 .globl  ecp_nistz256_gather_w5
1399 .type   ecp_nistz256_gather_w5,\@abi-omnipotent
1400 .align  32
1401 ecp_nistz256_gather_w5:
1402 ___
1403 $code.=<<___    if ($avx>1);
1404         mov     OPENSSL_ia32cap_P+8(%rip), %eax
1405         test    \$`1<<5`, %eax
1406         jnz     .Lavx2_gather_w5
1407 ___
1408 $code.=<<___    if ($win64);
1409         lea     -0x88(%rsp), %rax
1410 .LSEH_begin_ecp_nistz256_gather_w5:
1411         .byte   0x48,0x8d,0x60,0xe0             #lea    -0x20(%rax), %rsp
1412         .byte   0x0f,0x29,0x70,0xe0             #movaps %xmm6, -0x20(%rax)
1413         .byte   0x0f,0x29,0x78,0xf0             #movaps %xmm7, -0x10(%rax)
1414         .byte   0x44,0x0f,0x29,0x00             #movaps %xmm8, 0(%rax)
1415         .byte   0x44,0x0f,0x29,0x48,0x10        #movaps %xmm9, 0x10(%rax)
1416         .byte   0x44,0x0f,0x29,0x50,0x20        #movaps %xmm10, 0x20(%rax)
1417         .byte   0x44,0x0f,0x29,0x58,0x30        #movaps %xmm11, 0x30(%rax)
1418         .byte   0x44,0x0f,0x29,0x60,0x40        #movaps %xmm12, 0x40(%rax)
1419         .byte   0x44,0x0f,0x29,0x68,0x50        #movaps %xmm13, 0x50(%rax)
1420         .byte   0x44,0x0f,0x29,0x70,0x60        #movaps %xmm14, 0x60(%rax)
1421         .byte   0x44,0x0f,0x29,0x78,0x70        #movaps %xmm15, 0x70(%rax)
1422 ___
1423 $code.=<<___;
1424         movdqa  .LOne(%rip), $ONE
1425         movd    $index, $INDEX
1426
1427         pxor    $Ra, $Ra
1428         pxor    $Rb, $Rb
1429         pxor    $Rc, $Rc
1430         pxor    $Rd, $Rd
1431         pxor    $Re, $Re
1432         pxor    $Rf, $Rf
1433
1434         movdqa  $ONE, $M0
1435         pshufd  \$0, $INDEX, $INDEX
1436
1437         mov     \$16, %rax
1438 .Lselect_loop_sse_w5:
1439
1440         movdqa  $M0, $TMP0
1441         paddd   $ONE, $M0
1442         pcmpeqd $INDEX, $TMP0
1443
1444         movdqa  16*0($in_t), $T0a
1445         movdqa  16*1($in_t), $T0b
1446         movdqa  16*2($in_t), $T0c
1447         movdqa  16*3($in_t), $T0d
1448         movdqa  16*4($in_t), $T0e
1449         movdqa  16*5($in_t), $T0f
1450         lea 16*6($in_t), $in_t
1451
1452         pand    $TMP0, $T0a
1453         pand    $TMP0, $T0b
1454         por     $T0a, $Ra
1455         pand    $TMP0, $T0c
1456         por     $T0b, $Rb
1457         pand    $TMP0, $T0d
1458         por     $T0c, $Rc
1459         pand    $TMP0, $T0e
1460         por     $T0d, $Rd
1461         pand    $TMP0, $T0f
1462         por     $T0e, $Re
1463         por     $T0f, $Rf
1464
1465         dec     %rax
1466         jnz     .Lselect_loop_sse_w5
1467
1468         movdqu  $Ra, 16*0($val)
1469         movdqu  $Rb, 16*1($val)
1470         movdqu  $Rc, 16*2($val)
1471         movdqu  $Rd, 16*3($val)
1472         movdqu  $Re, 16*4($val)
1473         movdqu  $Rf, 16*5($val)
1474 ___
1475 $code.=<<___    if ($win64);
1476         movaps  (%rsp), %xmm6
1477         movaps  0x10(%rsp), %xmm7
1478         movaps  0x20(%rsp), %xmm8
1479         movaps  0x30(%rsp), %xmm9
1480         movaps  0x40(%rsp), %xmm10
1481         movaps  0x50(%rsp), %xmm11
1482         movaps  0x60(%rsp), %xmm12
1483         movaps  0x70(%rsp), %xmm13
1484         movaps  0x80(%rsp), %xmm14
1485         movaps  0x90(%rsp), %xmm15
1486         lea     0xa8(%rsp), %rsp
1487 .LSEH_end_ecp_nistz256_gather_w5:
1488 ___
1489 $code.=<<___;
1490         ret
1491 .size   ecp_nistz256_gather_w5,.-ecp_nistz256_gather_w5
1492
1493 ################################################################################
1494 # void ecp_nistz256_scatter_w7(uint64_t *val, uint64_t *in_t, int index);
1495 .globl  ecp_nistz256_scatter_w7
1496 .type   ecp_nistz256_scatter_w7,\@abi-omnipotent
1497 .align  32
1498 ecp_nistz256_scatter_w7:
1499         movdqu  0x00($in_t), %xmm0
1500         shl     \$6, $index
1501         movdqu  0x10($in_t), %xmm1
1502         movdqu  0x20($in_t), %xmm2
1503         movdqu  0x30($in_t), %xmm3
1504         movdqa  %xmm0, 0x00($val,$index)
1505         movdqa  %xmm1, 0x10($val,$index)
1506         movdqa  %xmm2, 0x20($val,$index)
1507         movdqa  %xmm3, 0x30($val,$index)
1508
1509         ret
1510 .size   ecp_nistz256_scatter_w7,.-ecp_nistz256_scatter_w7
1511
1512 ################################################################################
1513 # void ecp_nistz256_gather_w7(uint64_t *val, uint64_t *in_t, int index);
1514 .globl  ecp_nistz256_gather_w7
1515 .type   ecp_nistz256_gather_w7,\@abi-omnipotent
1516 .align  32
1517 ecp_nistz256_gather_w7:
1518 ___
1519 $code.=<<___    if ($avx>1);
1520         mov     OPENSSL_ia32cap_P+8(%rip), %eax
1521         test    \$`1<<5`, %eax
1522         jnz     .Lavx2_gather_w7
1523 ___
1524 $code.=<<___    if ($win64);
1525         lea     -0x88(%rsp), %rax
1526 .LSEH_begin_ecp_nistz256_gather_w7:
1527         .byte   0x48,0x8d,0x60,0xe0             #lea    -0x20(%rax), %rsp
1528         .byte   0x0f,0x29,0x70,0xe0             #movaps %xmm6, -0x20(%rax)
1529         .byte   0x0f,0x29,0x78,0xf0             #movaps %xmm7, -0x10(%rax)
1530         .byte   0x44,0x0f,0x29,0x00             #movaps %xmm8, 0(%rax)
1531         .byte   0x44,0x0f,0x29,0x48,0x10        #movaps %xmm9, 0x10(%rax)
1532         .byte   0x44,0x0f,0x29,0x50,0x20        #movaps %xmm10, 0x20(%rax)
1533         .byte   0x44,0x0f,0x29,0x58,0x30        #movaps %xmm11, 0x30(%rax)
1534         .byte   0x44,0x0f,0x29,0x60,0x40        #movaps %xmm12, 0x40(%rax)
1535         .byte   0x44,0x0f,0x29,0x68,0x50        #movaps %xmm13, 0x50(%rax)
1536         .byte   0x44,0x0f,0x29,0x70,0x60        #movaps %xmm14, 0x60(%rax)
1537         .byte   0x44,0x0f,0x29,0x78,0x70        #movaps %xmm15, 0x70(%rax)
1538 ___
1539 $code.=<<___;
1540         movdqa  .LOne(%rip), $M0
1541         movd    $index, $INDEX
1542
1543         pxor    $Ra, $Ra
1544         pxor    $Rb, $Rb
1545         pxor    $Rc, $Rc
1546         pxor    $Rd, $Rd
1547
1548         movdqa  $M0, $ONE
1549         pshufd  \$0, $INDEX, $INDEX
1550         mov     \$64, %rax
1551
1552 .Lselect_loop_sse_w7:
1553         movdqa  $M0, $TMP0
1554         paddd   $ONE, $M0
1555         movdqa  16*0($in_t), $T0a
1556         movdqa  16*1($in_t), $T0b
1557         pcmpeqd $INDEX, $TMP0
1558         movdqa  16*2($in_t), $T0c
1559         movdqa  16*3($in_t), $T0d
1560         lea     16*4($in_t), $in_t
1561
1562         pand    $TMP0, $T0a
1563         pand    $TMP0, $T0b
1564         por     $T0a, $Ra
1565         pand    $TMP0, $T0c
1566         por     $T0b, $Rb
1567         pand    $TMP0, $T0d
1568         por     $T0c, $Rc
1569         prefetcht0      255($in_t)
1570         por     $T0d, $Rd
1571
1572         dec     %rax
1573         jnz     .Lselect_loop_sse_w7
1574
1575         movdqu  $Ra, 16*0($val)
1576         movdqu  $Rb, 16*1($val)
1577         movdqu  $Rc, 16*2($val)
1578         movdqu  $Rd, 16*3($val)
1579 ___
1580 $code.=<<___    if ($win64);
1581         movaps  (%rsp), %xmm6
1582         movaps  0x10(%rsp), %xmm7
1583         movaps  0x20(%rsp), %xmm8
1584         movaps  0x30(%rsp), %xmm9
1585         movaps  0x40(%rsp), %xmm10
1586         movaps  0x50(%rsp), %xmm11
1587         movaps  0x60(%rsp), %xmm12
1588         movaps  0x70(%rsp), %xmm13
1589         movaps  0x80(%rsp), %xmm14
1590         movaps  0x90(%rsp), %xmm15
1591         lea     0xa8(%rsp), %rsp
1592 .LSEH_end_ecp_nistz256_gather_w7:
1593 ___
1594 $code.=<<___;
1595         ret
1596 .size   ecp_nistz256_gather_w7,.-ecp_nistz256_gather_w7
1597 ___
1598 }
1599 if ($avx>1) {
1600 my ($val,$in_t,$index)=$win64?("%rcx","%rdx","%r8d"):("%rdi","%rsi","%edx");
1601 my ($TWO,$INDEX,$Ra,$Rb,$Rc)=map("%ymm$_",(0..4));
1602 my ($M0,$T0a,$T0b,$T0c,$TMP0)=map("%ymm$_",(5..9));
1603 my ($M1,$T1a,$T1b,$T1c,$TMP1)=map("%ymm$_",(10..14));
1604
1605 $code.=<<___;
1606 ################################################################################
1607 # void ecp_nistz256_avx2_gather_w5(uint64_t *val, uint64_t *in_t, int index);
1608 .type   ecp_nistz256_avx2_gather_w5,\@abi-omnipotent
1609 .align  32
1610 ecp_nistz256_avx2_gather_w5:
1611 .Lavx2_gather_w5:
1612         vzeroupper
1613 ___
1614 $code.=<<___    if ($win64);
1615         lea     -0x88(%rsp), %rax
1616 .LSEH_begin_ecp_nistz256_avx2_gather_w5:
1617         .byte   0x48,0x8d,0x60,0xe0             #lea    -0x20(%rax), %rsp
1618         .byte   0xc5,0xf8,0x29,0x70,0xe0        #vmovaps %xmm6, -0x20(%rax)
1619         .byte   0xc5,0xf8,0x29,0x78,0xf0        #vmovaps %xmm7, -0x10(%rax)
1620         .byte   0xc5,0x78,0x29,0x40,0x00        #vmovaps %xmm8, 8(%rax)
1621         .byte   0xc5,0x78,0x29,0x48,0x10        #vmovaps %xmm9, 0x10(%rax)
1622         .byte   0xc5,0x78,0x29,0x50,0x20        #vmovaps %xmm10, 0x20(%rax)
1623         .byte   0xc5,0x78,0x29,0x58,0x30        #vmovaps %xmm11, 0x30(%rax)
1624         .byte   0xc5,0x78,0x29,0x60,0x40        #vmovaps %xmm12, 0x40(%rax)
1625         .byte   0xc5,0x78,0x29,0x68,0x50        #vmovaps %xmm13, 0x50(%rax)
1626         .byte   0xc5,0x78,0x29,0x70,0x60        #vmovaps %xmm14, 0x60(%rax)
1627         .byte   0xc5,0x78,0x29,0x78,0x70        #vmovaps %xmm15, 0x70(%rax)
1628 ___
1629 $code.=<<___;
1630         vmovdqa .LTwo(%rip), $TWO
1631
1632         vpxor   $Ra, $Ra, $Ra
1633         vpxor   $Rb, $Rb, $Rb
1634         vpxor   $Rc, $Rc, $Rc
1635
1636         vmovdqa .LOne(%rip), $M0
1637         vmovdqa .LTwo(%rip), $M1
1638
1639         vmovd   $index, %xmm1
1640         vpermd  $INDEX, $Ra, $INDEX
1641
1642         mov     \$8, %rax
1643 .Lselect_loop_avx2_w5:
1644
1645         vmovdqa 32*0($in_t), $T0a
1646         vmovdqa 32*1($in_t), $T0b
1647         vmovdqa 32*2($in_t), $T0c
1648
1649         vmovdqa 32*3($in_t), $T1a
1650         vmovdqa 32*4($in_t), $T1b
1651         vmovdqa 32*5($in_t), $T1c
1652
1653         vpcmpeqd        $INDEX, $M0, $TMP0
1654         vpcmpeqd        $INDEX, $M1, $TMP1
1655
1656         vpaddd  $TWO, $M0, $M0
1657         vpaddd  $TWO, $M1, $M1
1658         lea     32*6($in_t), $in_t
1659
1660         vpand   $TMP0, $T0a, $T0a
1661         vpand   $TMP0, $T0b, $T0b
1662         vpand   $TMP0, $T0c, $T0c
1663         vpand   $TMP1, $T1a, $T1a
1664         vpand   $TMP1, $T1b, $T1b
1665         vpand   $TMP1, $T1c, $T1c
1666
1667         vpxor   $T0a, $Ra, $Ra
1668         vpxor   $T0b, $Rb, $Rb
1669         vpxor   $T0c, $Rc, $Rc
1670         vpxor   $T1a, $Ra, $Ra
1671         vpxor   $T1b, $Rb, $Rb
1672         vpxor   $T1c, $Rc, $Rc
1673
1674         dec %rax
1675         jnz .Lselect_loop_avx2_w5
1676
1677         vmovdqu $Ra, 32*0($val)
1678         vmovdqu $Rb, 32*1($val)
1679         vmovdqu $Rc, 32*2($val)
1680         vzeroupper
1681 ___
1682 $code.=<<___    if ($win64);
1683         movaps  (%rsp), %xmm6
1684         movaps  0x10(%rsp), %xmm7
1685         movaps  0x20(%rsp), %xmm8
1686         movaps  0x30(%rsp), %xmm9
1687         movaps  0x40(%rsp), %xmm10
1688         movaps  0x50(%rsp), %xmm11
1689         movaps  0x60(%rsp), %xmm12
1690         movaps  0x70(%rsp), %xmm13
1691         movaps  0x80(%rsp), %xmm14
1692         movaps  0x90(%rsp), %xmm15
1693         lea     0xa8(%rsp), %rsp
1694 .LSEH_end_ecp_nistz256_avx2_gather_w5:
1695 ___
1696 $code.=<<___;
1697         ret
1698 .size   ecp_nistz256_avx2_gather_w5,.-ecp_nistz256_avx2_gather_w5
1699 ___
1700 }
1701 if ($avx>1) {
1702 my ($val,$in_t,$index)=$win64?("%rcx","%rdx","%r8d"):("%rdi","%rsi","%edx");
1703 my ($THREE,$INDEX,$Ra,$Rb)=map("%ymm$_",(0..3));
1704 my ($M0,$T0a,$T0b,$TMP0)=map("%ymm$_",(4..7));
1705 my ($M1,$T1a,$T1b,$TMP1)=map("%ymm$_",(8..11));
1706 my ($M2,$T2a,$T2b,$TMP2)=map("%ymm$_",(12..15));
1707
1708 $code.=<<___;
1709
1710 ################################################################################
1711 # void ecp_nistz256_avx2_gather_w7(uint64_t *val, uint64_t *in_t, int index);
1712 .globl  ecp_nistz256_avx2_gather_w7
1713 .type   ecp_nistz256_avx2_gather_w7,\@abi-omnipotent
1714 .align  32
1715 ecp_nistz256_avx2_gather_w7:
1716 .Lavx2_gather_w7:
1717         vzeroupper
1718 ___
1719 $code.=<<___    if ($win64);
1720         lea     -0x88(%rsp), %rax
1721 .LSEH_begin_ecp_nistz256_avx2_gather_w7:
1722         .byte   0x48,0x8d,0x60,0xe0             #lea    -0x20(%rax), %rsp
1723         .byte   0xc5,0xf8,0x29,0x70,0xe0        #vmovaps %xmm6, -0x20(%rax)
1724         .byte   0xc5,0xf8,0x29,0x78,0xf0        #vmovaps %xmm7, -0x10(%rax)
1725         .byte   0xc5,0x78,0x29,0x40,0x00        #vmovaps %xmm8, 8(%rax)
1726         .byte   0xc5,0x78,0x29,0x48,0x10        #vmovaps %xmm9, 0x10(%rax)
1727         .byte   0xc5,0x78,0x29,0x50,0x20        #vmovaps %xmm10, 0x20(%rax)
1728         .byte   0xc5,0x78,0x29,0x58,0x30        #vmovaps %xmm11, 0x30(%rax)
1729         .byte   0xc5,0x78,0x29,0x60,0x40        #vmovaps %xmm12, 0x40(%rax)
1730         .byte   0xc5,0x78,0x29,0x68,0x50        #vmovaps %xmm13, 0x50(%rax)
1731         .byte   0xc5,0x78,0x29,0x70,0x60        #vmovaps %xmm14, 0x60(%rax)
1732         .byte   0xc5,0x78,0x29,0x78,0x70        #vmovaps %xmm15, 0x70(%rax)
1733 ___
1734 $code.=<<___;
1735         vmovdqa .LThree(%rip), $THREE
1736
1737         vpxor   $Ra, $Ra, $Ra
1738         vpxor   $Rb, $Rb, $Rb
1739
1740         vmovdqa .LOne(%rip), $M0
1741         vmovdqa .LTwo(%rip), $M1
1742         vmovdqa .LThree(%rip), $M2
1743
1744         vmovd   $index, %xmm1
1745         vpermd  $INDEX, $Ra, $INDEX
1746         # Skip index = 0, because it is implicitly the point at infinity
1747
1748         mov     \$21, %rax
1749 .Lselect_loop_avx2_w7:
1750
1751         vmovdqa 32*0($in_t), $T0a
1752         vmovdqa 32*1($in_t), $T0b
1753
1754         vmovdqa 32*2($in_t), $T1a
1755         vmovdqa 32*3($in_t), $T1b
1756
1757         vmovdqa 32*4($in_t), $T2a
1758         vmovdqa 32*5($in_t), $T2b
1759
1760         vpcmpeqd        $INDEX, $M0, $TMP0
1761         vpcmpeqd        $INDEX, $M1, $TMP1
1762         vpcmpeqd        $INDEX, $M2, $TMP2
1763
1764         vpaddd  $THREE, $M0, $M0
1765         vpaddd  $THREE, $M1, $M1
1766         vpaddd  $THREE, $M2, $M2
1767         lea     32*6($in_t), $in_t
1768
1769         vpand   $TMP0, $T0a, $T0a
1770         vpand   $TMP0, $T0b, $T0b
1771         vpand   $TMP1, $T1a, $T1a
1772         vpand   $TMP1, $T1b, $T1b
1773         vpand   $TMP2, $T2a, $T2a
1774         vpand   $TMP2, $T2b, $T2b
1775
1776         vpxor   $T0a, $Ra, $Ra
1777         vpxor   $T0b, $Rb, $Rb
1778         vpxor   $T1a, $Ra, $Ra
1779         vpxor   $T1b, $Rb, $Rb
1780         vpxor   $T2a, $Ra, $Ra
1781         vpxor   $T2b, $Rb, $Rb
1782
1783         dec %rax
1784         jnz .Lselect_loop_avx2_w7
1785
1786
1787         vmovdqa 32*0($in_t), $T0a
1788         vmovdqa 32*1($in_t), $T0b
1789
1790         vpcmpeqd        $INDEX, $M0, $TMP0
1791
1792         vpand   $TMP0, $T0a, $T0a
1793         vpand   $TMP0, $T0b, $T0b
1794
1795         vpxor   $T0a, $Ra, $Ra
1796         vpxor   $T0b, $Rb, $Rb
1797
1798         vmovdqu $Ra, 32*0($val)
1799         vmovdqu $Rb, 32*1($val)
1800         vzeroupper
1801 ___
1802 $code.=<<___    if ($win64);
1803         movaps  (%rsp), %xmm6
1804         movaps  0x10(%rsp), %xmm7
1805         movaps  0x20(%rsp), %xmm8
1806         movaps  0x30(%rsp), %xmm9
1807         movaps  0x40(%rsp), %xmm10
1808         movaps  0x50(%rsp), %xmm11
1809         movaps  0x60(%rsp), %xmm12
1810         movaps  0x70(%rsp), %xmm13
1811         movaps  0x80(%rsp), %xmm14
1812         movaps  0x90(%rsp), %xmm15
1813         lea     0xa8(%rsp), %rsp
1814 .LSEH_end_ecp_nistz256_avx2_gather_w7:
1815 ___
1816 $code.=<<___;
1817         ret
1818 .size   ecp_nistz256_avx2_gather_w7,.-ecp_nistz256_avx2_gather_w7
1819 ___
1820 } else {
1821 $code.=<<___;
1822 .globl  ecp_nistz256_avx2_gather_w7
1823 .type   ecp_nistz256_avx2_gather_w7,\@function,3
1824 .align  32
1825 ecp_nistz256_avx2_gather_w7:
1826         .byte   0x0f,0x0b       # ud2
1827         ret
1828 .size   ecp_nistz256_avx2_gather_w7,.-ecp_nistz256_avx2_gather_w7
1829 ___
1830 }
1831 {{{
1832 ########################################################################
1833 # This block implements higher level point_double, point_add and
1834 # point_add_affine. The key to performance in this case is to allow
1835 # out-of-order execution logic to overlap computations from next step
1836 # with tail processing from current step. By using tailored calling
1837 # sequence we minimize inter-step overhead to give processor better
1838 # shot at overlapping operations...
1839 #
1840 # You will notice that input data is copied to stack. Trouble is that
1841 # there are no registers to spare for holding original pointers and
1842 # reloading them, pointers, would create undesired dependencies on
1843 # effective addresses calculation paths. In other words it's too done
1844 # to favour out-of-order execution logic.
1845 #                                               <appro@openssl.org>
1846
1847 my ($r_ptr,$a_ptr,$b_org,$b_ptr)=("%rdi","%rsi","%rdx","%rbx");
1848 my ($acc0,$acc1,$acc2,$acc3,$acc4,$acc5,$acc6,$acc7)=map("%r$_",(8..15));
1849 my ($t0,$t1,$t2,$t3,$t4)=("%rax","%rbp","%rcx",$acc4,$acc4);
1850 my ($poly1,$poly3)=($acc6,$acc7);
1851
1852 sub load_for_mul () {
1853 my ($a,$b,$src0) = @_;
1854 my $bias = $src0 eq "%rax" ? 0 : -128;
1855
1856 "       mov     $b, $src0
1857         lea     $b, $b_ptr
1858         mov     8*0+$a, $acc1
1859         mov     8*1+$a, $acc2
1860         lea     $bias+$a, $a_ptr
1861         mov     8*2+$a, $acc3
1862         mov     8*3+$a, $acc4"
1863 }
1864
1865 sub load_for_sqr () {
1866 my ($a,$src0) = @_;
1867 my $bias = $src0 eq "%rax" ? 0 : -128;
1868
1869 "       mov     8*0+$a, $src0
1870         mov     8*1+$a, $acc6
1871         lea     $bias+$a, $a_ptr
1872         mov     8*2+$a, $acc7
1873         mov     8*3+$a, $acc0"
1874 }
1875
1876                                                                         {
1877 ########################################################################
1878 # operate in 4-5-0-1 "name space" that matches multiplication output
1879 #
1880 my ($a0,$a1,$a2,$a3,$t3,$t4)=($acc4,$acc5,$acc0,$acc1,$acc2,$acc3);
1881
1882 $code.=<<___;
1883 .type   __ecp_nistz256_add_toq,\@abi-omnipotent
1884 .align  32
1885 __ecp_nistz256_add_toq:
1886         add     8*0($b_ptr), $a0
1887         adc     8*1($b_ptr), $a1
1888          mov    $a0, $t0
1889         adc     8*2($b_ptr), $a2
1890         adc     8*3($b_ptr), $a3
1891          mov    $a1, $t1
1892         sbb     $t4, $t4
1893
1894         sub     \$-1, $a0
1895          mov    $a2, $t2
1896         sbb     $poly1, $a1
1897         sbb     \$0, $a2
1898          mov    $a3, $t3
1899         sbb     $poly3, $a3
1900         test    $t4, $t4
1901
1902         cmovz   $t0, $a0
1903         cmovz   $t1, $a1
1904         mov     $a0, 8*0($r_ptr)
1905         cmovz   $t2, $a2
1906         mov     $a1, 8*1($r_ptr)
1907         cmovz   $t3, $a3
1908         mov     $a2, 8*2($r_ptr)
1909         mov     $a3, 8*3($r_ptr)
1910
1911         ret
1912 .size   __ecp_nistz256_add_toq,.-__ecp_nistz256_add_toq
1913
1914 .type   __ecp_nistz256_sub_fromq,\@abi-omnipotent
1915 .align  32
1916 __ecp_nistz256_sub_fromq:
1917         sub     8*0($b_ptr), $a0
1918         sbb     8*1($b_ptr), $a1
1919          mov    $a0, $t0
1920         sbb     8*2($b_ptr), $a2
1921         sbb     8*3($b_ptr), $a3
1922          mov    $a1, $t1
1923         sbb     $t4, $t4
1924
1925         add     \$-1, $a0
1926          mov    $a2, $t2
1927         adc     $poly1, $a1
1928         adc     \$0, $a2
1929          mov    $a3, $t3
1930         adc     $poly3, $a3
1931         test    $t4, $t4
1932
1933         cmovz   $t0, $a0
1934         cmovz   $t1, $a1
1935         mov     $a0, 8*0($r_ptr)
1936         cmovz   $t2, $a2
1937         mov     $a1, 8*1($r_ptr)
1938         cmovz   $t3, $a3
1939         mov     $a2, 8*2($r_ptr)
1940         mov     $a3, 8*3($r_ptr)
1941
1942         ret
1943 .size   __ecp_nistz256_sub_fromq,.-__ecp_nistz256_sub_fromq
1944
1945 .type   __ecp_nistz256_subq,\@abi-omnipotent
1946 .align  32
1947 __ecp_nistz256_subq:
1948         sub     $a0, $t0
1949         sbb     $a1, $t1
1950          mov    $t0, $a0
1951         sbb     $a2, $t2
1952         sbb     $a3, $t3
1953          mov    $t1, $a1
1954         sbb     $t4, $t4
1955
1956         add     \$-1, $t0
1957          mov    $t2, $a2
1958         adc     $poly1, $t1
1959         adc     \$0, $t2
1960          mov    $t3, $a3
1961         adc     $poly3, $t3
1962         test    $t4, $t4
1963
1964         cmovnz  $t0, $a0
1965         cmovnz  $t1, $a1
1966         cmovnz  $t2, $a2
1967         cmovnz  $t3, $a3
1968
1969         ret
1970 .size   __ecp_nistz256_subq,.-__ecp_nistz256_subq
1971
1972 .type   __ecp_nistz256_mul_by_2q,\@abi-omnipotent
1973 .align  32
1974 __ecp_nistz256_mul_by_2q:
1975         add     $a0, $a0                # a0:a3+a0:a3
1976         adc     $a1, $a1
1977          mov    $a0, $t0
1978         adc     $a2, $a2
1979         adc     $a3, $a3
1980          mov    $a1, $t1
1981         sbb     $t4, $t4
1982
1983         sub     \$-1, $a0
1984          mov    $a2, $t2
1985         sbb     $poly1, $a1
1986         sbb     \$0, $a2
1987          mov    $a3, $t3
1988         sbb     $poly3, $a3
1989         test    $t4, $t4
1990
1991         cmovz   $t0, $a0
1992         cmovz   $t1, $a1
1993         mov     $a0, 8*0($r_ptr)
1994         cmovz   $t2, $a2
1995         mov     $a1, 8*1($r_ptr)
1996         cmovz   $t3, $a3
1997         mov     $a2, 8*2($r_ptr)
1998         mov     $a3, 8*3($r_ptr)
1999
2000         ret
2001 .size   __ecp_nistz256_mul_by_2q,.-__ecp_nistz256_mul_by_2q
2002 ___
2003                                                                         }
2004 sub gen_double () {
2005     my $x = shift;
2006     my ($src0,$sfx,$bias);
2007     my ($S,$M,$Zsqr,$in_x,$tmp0)=map(32*$_,(0..4));
2008
2009     if ($x ne "x") {
2010         $src0 = "%rax";
2011         $sfx  = "";
2012         $bias = 0;
2013
2014 $code.=<<___;
2015 .globl  ecp_nistz256_point_double
2016 .type   ecp_nistz256_point_double,\@function,2
2017 .align  32
2018 ecp_nistz256_point_double:
2019 ___
2020 $code.=<<___    if ($addx);
2021         mov     \$0x80100, %ecx
2022         and     OPENSSL_ia32cap_P+8(%rip), %ecx
2023         cmp     \$0x80100, %ecx
2024         je      .Lpoint_doublex
2025 ___
2026     } else {
2027         $src0 = "%rdx";
2028         $sfx  = "x";
2029         $bias = 128;
2030
2031 $code.=<<___;
2032 .type   ecp_nistz256_point_doublex,\@function,2
2033 .align  32
2034 ecp_nistz256_point_doublex:
2035 .Lpoint_doublex:
2036 ___
2037     }
2038 $code.=<<___;
2039         push    %rbp
2040         push    %rbx
2041         push    %r12
2042         push    %r13
2043         push    %r14
2044         push    %r15
2045         sub     \$32*5+8, %rsp
2046
2047 .Lpoint_double_shortcut$x:
2048         movdqu  0x00($a_ptr), %xmm0             # copy  *(P256_POINT *)$a_ptr.x
2049         mov     $a_ptr, $b_ptr                  # backup copy
2050         movdqu  0x10($a_ptr), %xmm1
2051          mov    0x20+8*0($a_ptr), $acc4         # load in_y in "5-4-0-1" order
2052          mov    0x20+8*1($a_ptr), $acc5
2053          mov    0x20+8*2($a_ptr), $acc0
2054          mov    0x20+8*3($a_ptr), $acc1
2055          mov    .Lpoly+8*1(%rip), $poly1
2056          mov    .Lpoly+8*3(%rip), $poly3
2057         movdqa  %xmm0, $in_x(%rsp)
2058         movdqa  %xmm1, $in_x+0x10(%rsp)
2059         lea     0x20($r_ptr), $acc2
2060         lea     0x40($r_ptr), $acc3
2061         movq    $r_ptr, %xmm0
2062         movq    $acc2, %xmm1
2063         movq    $acc3, %xmm2
2064
2065         lea     $S(%rsp), $r_ptr
2066         call    __ecp_nistz256_mul_by_2$x       # p256_mul_by_2(S, in_y);
2067
2068         mov     0x40+8*0($a_ptr), $src0
2069         mov     0x40+8*1($a_ptr), $acc6
2070         mov     0x40+8*2($a_ptr), $acc7
2071         mov     0x40+8*3($a_ptr), $acc0
2072         lea     0x40-$bias($a_ptr), $a_ptr
2073         lea     $Zsqr(%rsp), $r_ptr
2074         call    __ecp_nistz256_sqr_mont$x       # p256_sqr_mont(Zsqr, in_z);
2075
2076         `&load_for_sqr("$S(%rsp)", "$src0")`
2077         lea     $S(%rsp), $r_ptr
2078         call    __ecp_nistz256_sqr_mont$x       # p256_sqr_mont(S, S);
2079
2080         mov     0x20($b_ptr), $src0             # $b_ptr is still valid
2081         mov     0x40+8*0($b_ptr), $acc1
2082         mov     0x40+8*1($b_ptr), $acc2
2083         mov     0x40+8*2($b_ptr), $acc3
2084         mov     0x40+8*3($b_ptr), $acc4
2085         lea     0x40-$bias($b_ptr), $a_ptr
2086         lea     0x20($b_ptr), $b_ptr
2087         movq    %xmm2, $r_ptr
2088         call    __ecp_nistz256_mul_mont$x       # p256_mul_mont(res_z, in_z, in_y);
2089         call    __ecp_nistz256_mul_by_2$x       # p256_mul_by_2(res_z, res_z);
2090
2091         mov     $in_x+8*0(%rsp), $acc4          # "5-4-0-1" order
2092         mov     $in_x+8*1(%rsp), $acc5
2093         lea     $Zsqr(%rsp), $b_ptr
2094         mov     $in_x+8*2(%rsp), $acc0
2095         mov     $in_x+8*3(%rsp), $acc1
2096         lea     $M(%rsp), $r_ptr
2097         call    __ecp_nistz256_add_to$x         # p256_add(M, in_x, Zsqr);
2098
2099         mov     $in_x+8*0(%rsp), $acc4          # "5-4-0-1" order
2100         mov     $in_x+8*1(%rsp), $acc5
2101         lea     $Zsqr(%rsp), $b_ptr
2102         mov     $in_x+8*2(%rsp), $acc0
2103         mov     $in_x+8*3(%rsp), $acc1
2104         lea     $Zsqr(%rsp), $r_ptr
2105         call    __ecp_nistz256_sub_from$x       # p256_sub(Zsqr, in_x, Zsqr);
2106
2107         `&load_for_sqr("$S(%rsp)", "$src0")`
2108         movq    %xmm1, $r_ptr
2109         call    __ecp_nistz256_sqr_mont$x       # p256_sqr_mont(res_y, S);
2110 ___
2111 {       
2112 ######## ecp_nistz256_div_by_2(res_y, res_y); ##########################
2113 # operate in 4-5-6-7 "name space" that matches squaring output
2114 #
2115 my ($poly1,$poly3)=($a_ptr,$t1);
2116 my ($a0,$a1,$a2,$a3,$t3,$t4,$t1)=($acc4,$acc5,$acc6,$acc7,$acc0,$acc1,$acc2);
2117
2118 $code.=<<___;
2119         xor     $t4, $t4
2120         mov     $a0, $t0
2121         add     \$-1, $a0
2122         mov     $a1, $t1
2123         adc     $poly1, $a1
2124         mov     $a2, $t2
2125         adc     \$0, $a2
2126         mov     $a3, $t3
2127         adc     $poly3, $a3
2128         adc     \$0, $t4
2129         xor     $a_ptr, $a_ptr          # borrow $a_ptr
2130         test    \$1, $t0
2131
2132         cmovz   $t0, $a0
2133         cmovz   $t1, $a1
2134         cmovz   $t2, $a2
2135         cmovz   $t3, $a3
2136         cmovz   $a_ptr, $t4
2137
2138         mov     $a1, $t0                # a0:a3>>1
2139         shr     \$1, $a0
2140         shl     \$63, $t0
2141         mov     $a2, $t1
2142         shr     \$1, $a1
2143         or      $t0, $a0
2144         shl     \$63, $t1
2145         mov     $a3, $t2
2146         shr     \$1, $a2
2147         or      $t1, $a1
2148         shl     \$63, $t2
2149         mov     $a0, 8*0($r_ptr)
2150         shr     \$1, $a3
2151         mov     $a1, 8*1($r_ptr)
2152         shl     \$63, $t4
2153         or      $t2, $a2
2154         or      $t4, $a3
2155         mov     $a2, 8*2($r_ptr)
2156         mov     $a3, 8*3($r_ptr)
2157 ___
2158 }
2159 $code.=<<___;
2160         `&load_for_mul("$M(%rsp)", "$Zsqr(%rsp)", "$src0")`
2161         lea     $M(%rsp), $r_ptr
2162         call    __ecp_nistz256_mul_mont$x       # p256_mul_mont(M, M, Zsqr);
2163
2164         lea     $tmp0(%rsp), $r_ptr
2165         call    __ecp_nistz256_mul_by_2$x
2166
2167         lea     $M(%rsp), $b_ptr
2168         lea     $M(%rsp), $r_ptr
2169         call    __ecp_nistz256_add_to$x         # p256_mul_by_3(M, M);
2170
2171         `&load_for_mul("$S(%rsp)", "$in_x(%rsp)", "$src0")`
2172         lea     $S(%rsp), $r_ptr
2173         call    __ecp_nistz256_mul_mont$x       # p256_mul_mont(S, S, in_x);
2174
2175         lea     $tmp0(%rsp), $r_ptr
2176         call    __ecp_nistz256_mul_by_2$x       # p256_mul_by_2(tmp0, S);
2177
2178         `&load_for_sqr("$M(%rsp)", "$src0")`
2179         movq    %xmm0, $r_ptr
2180         call    __ecp_nistz256_sqr_mont$x       # p256_sqr_mont(res_x, M);
2181
2182         lea     $tmp0(%rsp), $b_ptr
2183         mov     $acc6, $acc0                    # harmonize sqr output and sub input
2184         mov     $acc7, $acc1
2185         mov     $a_ptr, $poly1
2186         mov     $t1, $poly3
2187         call    __ecp_nistz256_sub_from$x       # p256_sub(res_x, res_x, tmp0);
2188
2189         mov     $S+8*0(%rsp), $t0
2190         mov     $S+8*1(%rsp), $t1
2191         mov     $S+8*2(%rsp), $t2
2192         mov     $S+8*3(%rsp), $acc2             # "4-5-0-1" order
2193         lea     $S(%rsp), $r_ptr
2194         call    __ecp_nistz256_sub$x            # p256_sub(S, S, res_x);
2195
2196         mov     $M(%rsp), $src0
2197         lea     $M(%rsp), $b_ptr
2198         mov     $acc4, $acc6                    # harmonize sub output and mul input
2199         xor     %ecx, %ecx
2200         mov     $acc4, $S+8*0(%rsp)             # have to save:-(       
2201         mov     $acc5, $acc2
2202         mov     $acc5, $S+8*1(%rsp)
2203         cmovz   $acc0, $acc3
2204         mov     $acc0, $S+8*2(%rsp)
2205         lea     $S-$bias(%rsp), $a_ptr
2206         cmovz   $acc1, $acc4
2207         mov     $acc1, $S+8*3(%rsp)
2208         mov     $acc6, $acc1
2209         lea     $S(%rsp), $r_ptr
2210         call    __ecp_nistz256_mul_mont$x       # p256_mul_mont(S, S, M);
2211
2212         movq    %xmm1, $b_ptr
2213         movq    %xmm1, $r_ptr
2214         call    __ecp_nistz256_sub_from$x       # p256_sub(res_y, S, res_y);
2215
2216         add     \$32*5+8, %rsp
2217         pop     %r15
2218         pop     %r14
2219         pop     %r13
2220         pop     %r12
2221         pop     %rbx
2222         pop     %rbp
2223         ret
2224 .size   ecp_nistz256_point_double$sfx,.-ecp_nistz256_point_double$sfx
2225 ___
2226 }
2227 &gen_double("q");
2228
2229 sub gen_add () {
2230     my $x = shift;
2231     my ($src0,$sfx,$bias);
2232     my ($H,$Hsqr,$R,$Rsqr,$Hcub,
2233         $U1,$U2,$S1,$S2,
2234         $res_x,$res_y,$res_z,
2235         $in1_x,$in1_y,$in1_z,
2236         $in2_x,$in2_y,$in2_z)=map(32*$_,(0..17));
2237     my ($Z1sqr, $Z2sqr) = ($Hsqr, $Rsqr);
2238
2239     if ($x ne "x") {
2240         $src0 = "%rax";
2241         $sfx  = "";
2242         $bias = 0;
2243
2244 $code.=<<___;
2245 .globl  ecp_nistz256_point_add
2246 .type   ecp_nistz256_point_add,\@function,3
2247 .align  32
2248 ecp_nistz256_point_add:
2249 ___
2250 $code.=<<___    if ($addx);
2251         mov     \$0x80100, %ecx
2252         and     OPENSSL_ia32cap_P+8(%rip), %ecx
2253         cmp     \$0x80100, %ecx
2254         je      .Lpoint_addx
2255 ___
2256     } else {
2257         $src0 = "%rdx";
2258         $sfx  = "x";
2259         $bias = 128;
2260
2261 $code.=<<___;
2262 .type   ecp_nistz256_point_addx,\@function,3
2263 .align  32
2264 ecp_nistz256_point_addx:
2265 .Lpoint_addx:
2266 ___
2267     }
2268 $code.=<<___;
2269         push    %rbp
2270         push    %rbx
2271         push    %r12
2272         push    %r13
2273         push    %r14
2274         push    %r15
2275         sub     \$32*18+8, %rsp
2276
2277         movdqu  0x00($a_ptr), %xmm0             # copy  *(P256_POINT *)$a_ptr
2278         movdqu  0x10($a_ptr), %xmm1
2279         movdqu  0x20($a_ptr), %xmm2
2280         movdqu  0x30($a_ptr), %xmm3
2281         movdqu  0x40($a_ptr), %xmm4
2282         movdqu  0x50($a_ptr), %xmm5
2283         mov     $a_ptr, $b_ptr                  # reassign
2284         mov     $b_org, $a_ptr                  # reassign
2285         movdqa  %xmm0, $in1_x(%rsp)
2286         movdqa  %xmm1, $in1_x+0x10(%rsp)
2287         por     %xmm0, %xmm1
2288         movdqa  %xmm2, $in1_y(%rsp)
2289         movdqa  %xmm3, $in1_y+0x10(%rsp)
2290         por     %xmm2, %xmm3
2291         movdqa  %xmm4, $in1_z(%rsp)
2292         movdqa  %xmm5, $in1_z+0x10(%rsp)
2293         por     %xmm1, %xmm3
2294
2295         movdqu  0x00($a_ptr), %xmm0             # copy  *(P256_POINT *)$b_ptr
2296          pshufd \$0xb1, %xmm3, %xmm5
2297         movdqu  0x10($a_ptr), %xmm1
2298         movdqu  0x20($a_ptr), %xmm2
2299          por    %xmm3, %xmm5
2300         movdqu  0x30($a_ptr), %xmm3
2301          mov    0x40+8*0($a_ptr), $src0         # load original in2_z
2302          mov    0x40+8*1($a_ptr), $acc6
2303          mov    0x40+8*2($a_ptr), $acc7
2304          mov    0x40+8*3($a_ptr), $acc0
2305         movdqa  %xmm0, $in2_x(%rsp)
2306          pshufd \$0x1e, %xmm5, %xmm4
2307         movdqa  %xmm1, $in2_x+0x10(%rsp)
2308         por     %xmm0, %xmm1
2309          movq   $r_ptr, %xmm0                   # save $r_ptr
2310         movdqa  %xmm2, $in2_y(%rsp)
2311         movdqa  %xmm3, $in2_y+0x10(%rsp)
2312         por     %xmm2, %xmm3
2313          por    %xmm4, %xmm5
2314          pxor   %xmm4, %xmm4
2315         por     %xmm1, %xmm3
2316
2317         lea     0x40-$bias($a_ptr), $a_ptr      # $a_ptr is still valid
2318          mov    $src0, $in2_z+8*0(%rsp)         # make in2_z copy
2319          mov    $acc6, $in2_z+8*1(%rsp)
2320          mov    $acc7, $in2_z+8*2(%rsp)
2321          mov    $acc0, $in2_z+8*3(%rsp)
2322         lea     $Z2sqr(%rsp), $r_ptr            # Z2^2
2323         call    __ecp_nistz256_sqr_mont$x       # p256_sqr_mont(Z2sqr, in2_z);
2324
2325         pcmpeqd %xmm4, %xmm5
2326         pshufd  \$0xb1, %xmm3, %xmm4
2327         por     %xmm3, %xmm4
2328         pshufd  \$0, %xmm5, %xmm5               # in1infty
2329         pshufd  \$0x1e, %xmm4, %xmm3
2330         por     %xmm3, %xmm4
2331         pxor    %xmm3, %xmm3
2332         pcmpeqd %xmm3, %xmm4
2333         pshufd  \$0, %xmm4, %xmm4               # in2infty
2334          mov    0x40+8*0($b_ptr), $src0         # load original in1_z
2335          mov    0x40+8*1($b_ptr), $acc6
2336          mov    0x40+8*2($b_ptr), $acc7
2337          mov    0x40+8*3($b_ptr), $acc0
2338         movq    $b_ptr, %xmm1
2339
2340         lea     0x40-$bias($b_ptr), $a_ptr
2341         lea     $Z1sqr(%rsp), $r_ptr            # Z1^2
2342         call    __ecp_nistz256_sqr_mont$x       # p256_sqr_mont(Z1sqr, in1_z);
2343
2344         `&load_for_mul("$Z2sqr(%rsp)", "$in2_z(%rsp)", "$src0")`
2345         lea     $S1(%rsp), $r_ptr               # S1 = Z2^3
2346         call    __ecp_nistz256_mul_mont$x       # p256_mul_mont(S1, Z2sqr, in2_z);
2347
2348         `&load_for_mul("$Z1sqr(%rsp)", "$in1_z(%rsp)", "$src0")`
2349         lea     $S2(%rsp), $r_ptr               # S2 = Z1^3
2350         call    __ecp_nistz256_mul_mont$x       # p256_mul_mont(S2, Z1sqr, in1_z);
2351
2352         `&load_for_mul("$S1(%rsp)", "$in1_y(%rsp)", "$src0")`
2353         lea     $S1(%rsp), $r_ptr               # S1 = Y1*Z2^3
2354         call    __ecp_nistz256_mul_mont$x       # p256_mul_mont(S1, S1, in1_y);
2355
2356         `&load_for_mul("$S2(%rsp)", "$in2_y(%rsp)", "$src0")`
2357         lea     $S2(%rsp), $r_ptr               # S2 = Y2*Z1^3
2358         call    __ecp_nistz256_mul_mont$x       # p256_mul_mont(S2, S2, in2_y);
2359
2360         lea     $S1(%rsp), $b_ptr
2361         lea     $R(%rsp), $r_ptr                # R = S2 - S1
2362         call    __ecp_nistz256_sub_from$x       # p256_sub(R, S2, S1);
2363
2364         or      $acc5, $acc4                    # see if result is zero
2365         movdqa  %xmm4, %xmm2
2366         or      $acc0, $acc4
2367         or      $acc1, $acc4
2368         por     %xmm5, %xmm2                    # in1infty || in2infty
2369         movq    $acc4, %xmm3
2370
2371         `&load_for_mul("$Z2sqr(%rsp)", "$in1_x(%rsp)", "$src0")`
2372         lea     $U1(%rsp), $r_ptr               # U1 = X1*Z2^2
2373         call    __ecp_nistz256_mul_mont$x       # p256_mul_mont(U1, in1_x, Z2sqr);
2374
2375         `&load_for_mul("$Z1sqr(%rsp)", "$in2_x(%rsp)", "$src0")`
2376         lea     $U2(%rsp), $r_ptr               # U2 = X2*Z1^2
2377         call    __ecp_nistz256_mul_mont$x       # p256_mul_mont(U2, in2_x, Z1sqr);
2378
2379         lea     $U1(%rsp), $b_ptr
2380         lea     $H(%rsp), $r_ptr                # H = U2 - U1
2381         call    __ecp_nistz256_sub_from$x       # p256_sub(H, U2, U1);
2382
2383         or      $acc5, $acc4                    # see if result is zero
2384         or      $acc0, $acc4
2385         or      $acc1, $acc4
2386
2387         .byte   0x3e                            # predict taken
2388         jnz     .Ladd_proceed$x                 # is_equal(U1,U2)?
2389         movq    %xmm2, $acc0
2390         movq    %xmm3, $acc1
2391         test    $acc0, $acc0
2392         jnz     .Ladd_proceed$x                 # (in1infty || in2infty)?
2393         test    $acc1, $acc1
2394         jz      .Ladd_double$x                  # is_equal(S1,S2)?
2395
2396         movq    %xmm0, $r_ptr                   # restore $r_ptr
2397         pxor    %xmm0, %xmm0
2398         movdqu  %xmm0, 0x00($r_ptr)
2399         movdqu  %xmm0, 0x10($r_ptr)
2400         movdqu  %xmm0, 0x20($r_ptr)
2401         movdqu  %xmm0, 0x30($r_ptr)
2402         movdqu  %xmm0, 0x40($r_ptr)
2403         movdqu  %xmm0, 0x50($r_ptr)
2404         jmp     .Ladd_done$x
2405
2406 .align  32
2407 .Ladd_double$x:
2408         movq    %xmm1, $a_ptr                   # restore $a_ptr
2409         movq    %xmm0, $r_ptr                   # restore $r_ptr
2410         add     \$`32*(18-5)`, %rsp             # difference in frame sizes
2411         jmp     .Lpoint_double_shortcut$x
2412
2413 .align  32
2414 .Ladd_proceed$x:
2415         `&load_for_sqr("$R(%rsp)", "$src0")`
2416         lea     $Rsqr(%rsp), $r_ptr             # R^2
2417         call    __ecp_nistz256_sqr_mont$x       # p256_sqr_mont(Rsqr, R);
2418
2419         `&load_for_mul("$H(%rsp)", "$in1_z(%rsp)", "$src0")`
2420         lea     $res_z(%rsp), $r_ptr            # Z3 = H*Z1*Z2
2421         call    __ecp_nistz256_mul_mont$x       # p256_mul_mont(res_z, H, in1_z);
2422
2423         `&load_for_sqr("$H(%rsp)", "$src0")`
2424         lea     $Hsqr(%rsp), $r_ptr             # H^2
2425         call    __ecp_nistz256_sqr_mont$x       # p256_sqr_mont(Hsqr, H);
2426
2427         `&load_for_mul("$res_z(%rsp)", "$in2_z(%rsp)", "$src0")`
2428         lea     $res_z(%rsp), $r_ptr            # Z3 = H*Z1*Z2
2429         call    __ecp_nistz256_mul_mont$x       # p256_mul_mont(res_z, res_z, in2_z);
2430
2431         `&load_for_mul("$Hsqr(%rsp)", "$H(%rsp)", "$src0")`
2432         lea     $Hcub(%rsp), $r_ptr             # H^3
2433         call    __ecp_nistz256_mul_mont$x       # p256_mul_mont(Hcub, Hsqr, H);
2434
2435         `&load_for_mul("$Hsqr(%rsp)", "$U1(%rsp)", "$src0")`
2436         lea     $U2(%rsp), $r_ptr               # U1*H^2
2437         call    __ecp_nistz256_mul_mont$x       # p256_mul_mont(U2, U1, Hsqr);
2438 ___
2439 {
2440 #######################################################################
2441 # operate in 4-5-0-1 "name space" that matches multiplication output
2442 #
2443 my ($acc0,$acc1,$acc2,$acc3,$t3,$t4)=($acc4,$acc5,$acc0,$acc1,$acc2,$acc3);
2444 my ($poly1, $poly3)=($acc6,$acc7);
2445
2446 $code.=<<___;
2447         #lea    $U2(%rsp), $a_ptr
2448         #lea    $Hsqr(%rsp), $r_ptr     # 2*U1*H^2
2449         #call   __ecp_nistz256_mul_by_2 # ecp_nistz256_mul_by_2(Hsqr, U2);
2450
2451         add     $acc0, $acc0            # a0:a3+a0:a3
2452         lea     $Rsqr(%rsp), $a_ptr
2453         adc     $acc1, $acc1
2454          mov    $acc0, $t0
2455         adc     $acc2, $acc2
2456         adc     $acc3, $acc3
2457          mov    $acc1, $t1
2458         sbb     $t4, $t4
2459
2460         sub     \$-1, $acc0
2461          mov    $acc2, $t2
2462         sbb     $poly1, $acc1
2463         sbb     \$0, $acc2
2464          mov    $acc3, $t3
2465         sbb     $poly3, $acc3
2466         test    $t4, $t4
2467
2468         cmovz   $t0, $acc0
2469         mov     8*0($a_ptr), $t0
2470         cmovz   $t1, $acc1
2471         mov     8*1($a_ptr), $t1
2472         cmovz   $t2, $acc2
2473         mov     8*2($a_ptr), $t2
2474         cmovz   $t3, $acc3
2475         mov     8*3($a_ptr), $t3
2476
2477         call    __ecp_nistz256_sub$x            # p256_sub(res_x, Rsqr, Hsqr);
2478
2479         lea     $Hcub(%rsp), $b_ptr
2480         lea     $res_x(%rsp), $r_ptr
2481         call    __ecp_nistz256_sub_from$x       # p256_sub(res_x, res_x, Hcub);
2482
2483         mov     $U2+8*0(%rsp), $t0
2484         mov     $U2+8*1(%rsp), $t1
2485         mov     $U2+8*2(%rsp), $t2
2486         mov     $U2+8*3(%rsp), $t3
2487         lea     $res_y(%rsp), $r_ptr
2488
2489         call    __ecp_nistz256_sub$x            # p256_sub(res_y, U2, res_x);
2490
2491         mov     $acc0, 8*0($r_ptr)              # save the result, as
2492         mov     $acc1, 8*1($r_ptr)              # __ecp_nistz256_sub doesn't
2493         mov     $acc2, 8*2($r_ptr)
2494         mov     $acc3, 8*3($r_ptr)
2495 ___
2496 }
2497 $code.=<<___;
2498         `&load_for_mul("$S1(%rsp)", "$Hcub(%rsp)", "$src0")`
2499         lea     $S2(%rsp), $r_ptr
2500         call    __ecp_nistz256_mul_mont$x       # p256_mul_mont(S2, S1, Hcub);
2501
2502         `&load_for_mul("$R(%rsp)", "$res_y(%rsp)", "$src0")`
2503         lea     $res_y(%rsp), $r_ptr
2504         call    __ecp_nistz256_mul_mont$x       # p256_mul_mont(res_y, R, res_y);
2505
2506         lea     $S2(%rsp), $b_ptr
2507         lea     $res_y(%rsp), $r_ptr
2508         call    __ecp_nistz256_sub_from$x       # p256_sub(res_y, res_y, S2);
2509
2510         movq    %xmm0, $r_ptr           # restore $r_ptr
2511
2512         movdqa  %xmm5, %xmm0            # copy_conditional(res_z, in2_z, in1infty);
2513         movdqa  %xmm5, %xmm1
2514         pandn   $res_z(%rsp), %xmm0
2515         movdqa  %xmm5, %xmm2
2516         pandn   $res_z+0x10(%rsp), %xmm1
2517         movdqa  %xmm5, %xmm3
2518         pand    $in2_z(%rsp), %xmm2
2519         pand    $in2_z+0x10(%rsp), %xmm3
2520         por     %xmm0, %xmm2
2521         por     %xmm1, %xmm3
2522
2523         movdqa  %xmm4, %xmm0            # copy_conditional(res_z, in1_z, in2infty);
2524         movdqa  %xmm4, %xmm1
2525         pandn   %xmm2, %xmm0
2526         movdqa  %xmm4, %xmm2
2527         pandn   %xmm3, %xmm1
2528         movdqa  %xmm4, %xmm3
2529         pand    $in1_z(%rsp), %xmm2
2530         pand    $in1_z+0x10(%rsp), %xmm3
2531         por     %xmm0, %xmm2
2532         por     %xmm1, %xmm3
2533         movdqu  %xmm2, 0x40($r_ptr)
2534         movdqu  %xmm3, 0x50($r_ptr)
2535
2536         movdqa  %xmm5, %xmm0            # copy_conditional(res_x, in2_x, in1infty);
2537         movdqa  %xmm5, %xmm1
2538         pandn   $res_x(%rsp), %xmm0
2539         movdqa  %xmm5, %xmm2
2540         pandn   $res_x+0x10(%rsp), %xmm1
2541         movdqa  %xmm5, %xmm3
2542         pand    $in2_x(%rsp), %xmm2
2543         pand    $in2_x+0x10(%rsp), %xmm3
2544         por     %xmm0, %xmm2
2545         por     %xmm1, %xmm3
2546
2547         movdqa  %xmm4, %xmm0            # copy_conditional(res_x, in1_x, in2infty);
2548         movdqa  %xmm4, %xmm1
2549         pandn   %xmm2, %xmm0
2550         movdqa  %xmm4, %xmm2
2551         pandn   %xmm3, %xmm1
2552         movdqa  %xmm4, %xmm3
2553         pand    $in1_x(%rsp), %xmm2
2554         pand    $in1_x+0x10(%rsp), %xmm3
2555         por     %xmm0, %xmm2
2556         por     %xmm1, %xmm3
2557         movdqu  %xmm2, 0x00($r_ptr)
2558         movdqu  %xmm3, 0x10($r_ptr)
2559
2560         movdqa  %xmm5, %xmm0            # copy_conditional(res_y, in2_y, in1infty);
2561         movdqa  %xmm5, %xmm1
2562         pandn   $res_y(%rsp), %xmm0
2563         movdqa  %xmm5, %xmm2
2564         pandn   $res_y+0x10(%rsp), %xmm1
2565         movdqa  %xmm5, %xmm3
2566         pand    $in2_y(%rsp), %xmm2
2567         pand    $in2_y+0x10(%rsp), %xmm3
2568         por     %xmm0, %xmm2
2569         por     %xmm1, %xmm3
2570
2571         movdqa  %xmm4, %xmm0            # copy_conditional(res_y, in1_y, in2infty);
2572         movdqa  %xmm4, %xmm1
2573         pandn   %xmm2, %xmm0
2574         movdqa  %xmm4, %xmm2
2575         pandn   %xmm3, %xmm1
2576         movdqa  %xmm4, %xmm3
2577         pand    $in1_y(%rsp), %xmm2
2578         pand    $in1_y+0x10(%rsp), %xmm3
2579         por     %xmm0, %xmm2
2580         por     %xmm1, %xmm3
2581         movdqu  %xmm2, 0x20($r_ptr)
2582         movdqu  %xmm3, 0x30($r_ptr)
2583
2584 .Ladd_done$x:
2585         add     \$32*18+8, %rsp
2586         pop     %r15
2587         pop     %r14
2588         pop     %r13
2589         pop     %r12
2590         pop     %rbx
2591         pop     %rbp
2592         ret
2593 .size   ecp_nistz256_point_add$sfx,.-ecp_nistz256_point_add$sfx
2594 ___
2595 }
2596 &gen_add("q");
2597
2598 sub gen_add_affine () {
2599     my $x = shift;
2600     my ($src0,$sfx,$bias);
2601     my ($U2,$S2,$H,$R,$Hsqr,$Hcub,$Rsqr,
2602         $res_x,$res_y,$res_z,
2603         $in1_x,$in1_y,$in1_z,
2604         $in2_x,$in2_y)=map(32*$_,(0..14));
2605     my $Z1sqr = $S2;
2606
2607     if ($x ne "x") {
2608         $src0 = "%rax";
2609         $sfx  = "";
2610         $bias = 0;
2611
2612 $code.=<<___;
2613 .globl  ecp_nistz256_point_add_affine
2614 .type   ecp_nistz256_point_add_affine,\@function,3
2615 .align  32
2616 ecp_nistz256_point_add_affine:
2617 ___
2618 $code.=<<___    if ($addx);
2619         mov     \$0x80100, %ecx
2620         and     OPENSSL_ia32cap_P+8(%rip), %ecx
2621         cmp     \$0x80100, %ecx
2622         je      .Lpoint_add_affinex
2623 ___
2624     } else {
2625         $src0 = "%rdx";
2626         $sfx  = "x";
2627         $bias = 128;
2628
2629 $code.=<<___;
2630 .type   ecp_nistz256_point_add_affinex,\@function,3
2631 .align  32
2632 ecp_nistz256_point_add_affinex:
2633 .Lpoint_add_affinex:
2634 ___
2635     }
2636 $code.=<<___;
2637         push    %rbp
2638         push    %rbx
2639         push    %r12
2640         push    %r13
2641         push    %r14
2642         push    %r15
2643         sub     \$32*15+8, %rsp
2644
2645         movdqu  0x00($a_ptr), %xmm0     # copy  *(P256_POINT *)$a_ptr
2646         mov     $b_org, $b_ptr          # reassign
2647         movdqu  0x10($a_ptr), %xmm1
2648         movdqu  0x20($a_ptr), %xmm2
2649         movdqu  0x30($a_ptr), %xmm3
2650         movdqu  0x40($a_ptr), %xmm4
2651         movdqu  0x50($a_ptr), %xmm5
2652          mov    0x40+8*0($a_ptr), $src0 # load original in1_z
2653          mov    0x40+8*1($a_ptr), $acc6
2654          mov    0x40+8*2($a_ptr), $acc7
2655          mov    0x40+8*3($a_ptr), $acc0
2656         movdqa  %xmm0, $in1_x(%rsp)
2657         movdqa  %xmm1, $in1_x+0x10(%rsp)
2658         por     %xmm0, %xmm1
2659         movdqa  %xmm2, $in1_y(%rsp)
2660         movdqa  %xmm3, $in1_y+0x10(%rsp)
2661         por     %xmm2, %xmm3
2662         movdqa  %xmm4, $in1_z(%rsp)
2663         movdqa  %xmm5, $in1_z+0x10(%rsp)
2664         por     %xmm1, %xmm3
2665
2666         movdqu  0x00($b_ptr), %xmm0     # copy  *(P256_POINT_AFFINE *)$b_ptr
2667          pshufd \$0xb1, %xmm3, %xmm5
2668         movdqu  0x10($b_ptr), %xmm1
2669         movdqu  0x20($b_ptr), %xmm2
2670          por    %xmm3, %xmm5
2671         movdqu  0x30($b_ptr), %xmm3
2672         movdqa  %xmm0, $in2_x(%rsp)
2673          pshufd \$0x1e, %xmm5, %xmm4
2674         movdqa  %xmm1, $in2_x+0x10(%rsp)
2675         por     %xmm0, %xmm1
2676          movq   $r_ptr, %xmm0           # save $r_ptr
2677         movdqa  %xmm2, $in2_y(%rsp)
2678         movdqa  %xmm3, $in2_y+0x10(%rsp)
2679         por     %xmm2, %xmm3
2680          por    %xmm4, %xmm5
2681          pxor   %xmm4, %xmm4
2682         por     %xmm1, %xmm3
2683
2684         lea     0x40-$bias($a_ptr), $a_ptr      # $a_ptr is still valid
2685         lea     $Z1sqr(%rsp), $r_ptr            # Z1^2
2686         call    __ecp_nistz256_sqr_mont$x       # p256_sqr_mont(Z1sqr, in1_z);
2687
2688         pcmpeqd %xmm4, %xmm5
2689         pshufd  \$0xb1, %xmm3, %xmm4
2690          mov    0x00($b_ptr), $src0             # $b_ptr is still valid
2691          #lea   0x00($b_ptr), $b_ptr
2692          mov    $acc4, $acc1                    # harmonize sqr output and mul input
2693         por     %xmm3, %xmm4
2694         pshufd  \$0, %xmm5, %xmm5               # in1infty
2695         pshufd  \$0x1e, %xmm4, %xmm3
2696          mov    $acc5, $acc2
2697         por     %xmm3, %xmm4
2698         pxor    %xmm3, %xmm3
2699          mov    $acc6, $acc3
2700         pcmpeqd %xmm3, %xmm4
2701         pshufd  \$0, %xmm4, %xmm4               # in2infty
2702
2703         lea     $Z1sqr-$bias(%rsp), $a_ptr
2704         mov     $acc7, $acc4
2705         lea     $U2(%rsp), $r_ptr               # U2 = X2*Z1^2
2706         call    __ecp_nistz256_mul_mont$x       # p256_mul_mont(U2, Z1sqr, in2_x);
2707
2708         lea     $in1_x(%rsp), $b_ptr
2709         lea     $H(%rsp), $r_ptr                # H = U2 - U1
2710         call    __ecp_nistz256_sub_from$x       # p256_sub(H, U2, in1_x);
2711
2712         `&load_for_mul("$Z1sqr(%rsp)", "$in1_z(%rsp)", "$src0")`
2713         lea     $S2(%rsp), $r_ptr               # S2 = Z1^3
2714         call    __ecp_nistz256_mul_mont$x       # p256_mul_mont(S2, Z1sqr, in1_z);
2715
2716         `&load_for_mul("$H(%rsp)", "$in1_z(%rsp)", "$src0")`
2717         lea     $res_z(%rsp), $r_ptr            # Z3 = H*Z1*Z2
2718         call    __ecp_nistz256_mul_mont$x       # p256_mul_mont(res_z, H, in1_z);
2719
2720         `&load_for_mul("$S2(%rsp)", "$in2_y(%rsp)", "$src0")`
2721         lea     $S2(%rsp), $r_ptr               # S2 = Y2*Z1^3
2722         call    __ecp_nistz256_mul_mont$x       # p256_mul_mont(S2, S2, in2_y);
2723
2724         lea     $in1_y(%rsp), $b_ptr
2725         lea     $R(%rsp), $r_ptr                # R = S2 - S1
2726         call    __ecp_nistz256_sub_from$x       # p256_sub(R, S2, in1_y);
2727
2728         `&load_for_sqr("$H(%rsp)", "$src0")`
2729         lea     $Hsqr(%rsp), $r_ptr             # H^2
2730         call    __ecp_nistz256_sqr_mont$x       # p256_sqr_mont(Hsqr, H);
2731
2732         `&load_for_sqr("$R(%rsp)", "$src0")`
2733         lea     $Rsqr(%rsp), $r_ptr             # R^2
2734         call    __ecp_nistz256_sqr_mont$x       # p256_sqr_mont(Rsqr, R);
2735
2736         `&load_for_mul("$H(%rsp)", "$Hsqr(%rsp)", "$src0")`
2737         lea     $Hcub(%rsp), $r_ptr             # H^3
2738         call    __ecp_nistz256_mul_mont$x       # p256_mul_mont(Hcub, Hsqr, H);
2739
2740         `&load_for_mul("$Hsqr(%rsp)", "$in1_x(%rsp)", "$src0")`
2741         lea     $U2(%rsp), $r_ptr               # U1*H^2
2742         call    __ecp_nistz256_mul_mont$x       # p256_mul_mont(U2, in1_x, Hsqr);
2743 ___
2744 {
2745 #######################################################################
2746 # operate in 4-5-0-1 "name space" that matches multiplication output
2747 #
2748 my ($acc0,$acc1,$acc2,$acc3,$t3,$t4)=($acc4,$acc5,$acc0,$acc1,$acc2,$acc3);
2749 my ($poly1, $poly3)=($acc6,$acc7);
2750
2751 $code.=<<___;
2752         #lea    $U2(%rsp), $a_ptr
2753         #lea    $Hsqr(%rsp), $r_ptr     # 2*U1*H^2
2754         #call   __ecp_nistz256_mul_by_2 # ecp_nistz256_mul_by_2(Hsqr, U2);
2755
2756         add     $acc0, $acc0            # a0:a3+a0:a3
2757         lea     $Rsqr(%rsp), $a_ptr
2758         adc     $acc1, $acc1
2759          mov    $acc0, $t0
2760         adc     $acc2, $acc2
2761         adc     $acc3, $acc3
2762          mov    $acc1, $t1
2763         sbb     $t4, $t4
2764
2765         sub     \$-1, $acc0
2766          mov    $acc2, $t2
2767         sbb     $poly1, $acc1
2768         sbb     \$0, $acc2
2769          mov    $acc3, $t3
2770         sbb     $poly3, $acc3
2771         test    $t4, $t4
2772
2773         cmovz   $t0, $acc0
2774         mov     8*0($a_ptr), $t0
2775         cmovz   $t1, $acc1
2776         mov     8*1($a_ptr), $t1
2777         cmovz   $t2, $acc2
2778         mov     8*2($a_ptr), $t2
2779         cmovz   $t3, $acc3
2780         mov     8*3($a_ptr), $t3
2781
2782         call    __ecp_nistz256_sub$x            # p256_sub(res_x, Rsqr, Hsqr);
2783
2784         lea     $Hcub(%rsp), $b_ptr
2785         lea     $res_x(%rsp), $r_ptr
2786         call    __ecp_nistz256_sub_from$x       # p256_sub(res_x, res_x, Hcub);
2787
2788         mov     $U2+8*0(%rsp), $t0
2789         mov     $U2+8*1(%rsp), $t1
2790         mov     $U2+8*2(%rsp), $t2
2791         mov     $U2+8*3(%rsp), $t3
2792         lea     $H(%rsp), $r_ptr
2793
2794         call    __ecp_nistz256_sub$x            # p256_sub(H, U2, res_x);
2795
2796         mov     $acc0, 8*0($r_ptr)              # save the result, as
2797         mov     $acc1, 8*1($r_ptr)              # __ecp_nistz256_sub doesn't
2798         mov     $acc2, 8*2($r_ptr)
2799         mov     $acc3, 8*3($r_ptr)
2800 ___
2801 }
2802 $code.=<<___;
2803         `&load_for_mul("$Hcub(%rsp)", "$in1_y(%rsp)", "$src0")`
2804         lea     $S2(%rsp), $r_ptr
2805         call    __ecp_nistz256_mul_mont$x       # p256_mul_mont(S2, Hcub, in1_y);
2806
2807         `&load_for_mul("$H(%rsp)", "$R(%rsp)", "$src0")`
2808         lea     $H(%rsp), $r_ptr
2809         call    __ecp_nistz256_mul_mont$x       # p256_mul_mont(H, H, R);
2810
2811         lea     $S2(%rsp), $b_ptr
2812         lea     $res_y(%rsp), $r_ptr
2813         call    __ecp_nistz256_sub_from$x       # p256_sub(res_y, H, S2);
2814
2815         movq    %xmm0, $r_ptr           # restore $r_ptr
2816
2817         movdqa  %xmm5, %xmm0            # copy_conditional(res_z, ONE, in1infty);
2818         movdqa  %xmm5, %xmm1
2819         pandn   $res_z(%rsp), %xmm0
2820         movdqa  %xmm5, %xmm2
2821         pandn   $res_z+0x10(%rsp), %xmm1
2822         movdqa  %xmm5, %xmm3
2823         pand    .LONE_mont(%rip), %xmm2
2824         pand    .LONE_mont+0x10(%rip), %xmm3
2825         por     %xmm0, %xmm2
2826         por     %xmm1, %xmm3
2827
2828         movdqa  %xmm4, %xmm0            # copy_conditional(res_z, in1_z, in2infty);
2829         movdqa  %xmm4, %xmm1
2830         pandn   %xmm2, %xmm0
2831         movdqa  %xmm4, %xmm2
2832         pandn   %xmm3, %xmm1
2833         movdqa  %xmm4, %xmm3
2834         pand    $in1_z(%rsp), %xmm2
2835         pand    $in1_z+0x10(%rsp), %xmm3
2836         por     %xmm0, %xmm2
2837         por     %xmm1, %xmm3
2838         movdqu  %xmm2, 0x40($r_ptr)
2839         movdqu  %xmm3, 0x50($r_ptr)
2840
2841         movdqa  %xmm5, %xmm0            # copy_conditional(res_x, in2_x, in1infty);
2842         movdqa  %xmm5, %xmm1
2843         pandn   $res_x(%rsp), %xmm0
2844         movdqa  %xmm5, %xmm2
2845         pandn   $res_x+0x10(%rsp), %xmm1
2846         movdqa  %xmm5, %xmm3
2847         pand    $in2_x(%rsp), %xmm2
2848         pand    $in2_x+0x10(%rsp), %xmm3
2849         por     %xmm0, %xmm2
2850         por     %xmm1, %xmm3
2851
2852         movdqa  %xmm4, %xmm0            # copy_conditional(res_x, in1_x, in2infty);
2853         movdqa  %xmm4, %xmm1
2854         pandn   %xmm2, %xmm0
2855         movdqa  %xmm4, %xmm2
2856         pandn   %xmm3, %xmm1
2857         movdqa  %xmm4, %xmm3
2858         pand    $in1_x(%rsp), %xmm2
2859         pand    $in1_x+0x10(%rsp), %xmm3
2860         por     %xmm0, %xmm2
2861         por     %xmm1, %xmm3
2862         movdqu  %xmm2, 0x00($r_ptr)
2863         movdqu  %xmm3, 0x10($r_ptr)
2864
2865         movdqa  %xmm5, %xmm0            # copy_conditional(res_y, in2_y, in1infty);
2866         movdqa  %xmm5, %xmm1
2867         pandn   $res_y(%rsp), %xmm0
2868         movdqa  %xmm5, %xmm2
2869         pandn   $res_y+0x10(%rsp), %xmm1
2870         movdqa  %xmm5, %xmm3
2871         pand    $in2_y(%rsp), %xmm2
2872         pand    $in2_y+0x10(%rsp), %xmm3
2873         por     %xmm0, %xmm2
2874         por     %xmm1, %xmm3
2875
2876         movdqa  %xmm4, %xmm0            # copy_conditional(res_y, in1_y, in2infty);
2877         movdqa  %xmm4, %xmm1
2878         pandn   %xmm2, %xmm0
2879         movdqa  %xmm4, %xmm2
2880         pandn   %xmm3, %xmm1
2881         movdqa  %xmm4, %xmm3
2882         pand    $in1_y(%rsp), %xmm2
2883         pand    $in1_y+0x10(%rsp), %xmm3
2884         por     %xmm0, %xmm2
2885         por     %xmm1, %xmm3
2886         movdqu  %xmm2, 0x20($r_ptr)
2887         movdqu  %xmm3, 0x30($r_ptr)
2888
2889         add     \$32*15+8, %rsp
2890         pop     %r15
2891         pop     %r14
2892         pop     %r13
2893         pop     %r12
2894         pop     %rbx
2895         pop     %rbp
2896         ret
2897 .size   ecp_nistz256_point_add_affine$sfx,.-ecp_nistz256_point_add_affine$sfx
2898 ___
2899 }
2900 &gen_add_affine("q");
2901
2902 ########################################################################
2903 # AD*X magic
2904 #
2905 if ($addx) {                                                            {
2906 ########################################################################
2907 # operate in 4-5-0-1 "name space" that matches multiplication output
2908 #
2909 my ($a0,$a1,$a2,$a3,$t3,$t4)=($acc4,$acc5,$acc0,$acc1,$acc2,$acc3);
2910
2911 $code.=<<___;
2912 .type   __ecp_nistz256_add_tox,\@abi-omnipotent
2913 .align  32
2914 __ecp_nistz256_add_tox:
2915         xor     $t4, $t4
2916         adc     8*0($b_ptr), $a0
2917         adc     8*1($b_ptr), $a1
2918          mov    $a0, $t0
2919         adc     8*2($b_ptr), $a2
2920         adc     8*3($b_ptr), $a3
2921          mov    $a1, $t1
2922         adc     \$0, $t4
2923
2924         xor     $t3, $t3
2925         sbb     \$-1, $a0
2926          mov    $a2, $t2
2927         sbb     $poly1, $a1
2928         sbb     \$0, $a2
2929          mov    $a3, $t3
2930         sbb     $poly3, $a3
2931
2932         bt      \$0, $t4
2933         cmovnc  $t0, $a0
2934         cmovnc  $t1, $a1
2935         mov     $a0, 8*0($r_ptr)
2936         cmovnc  $t2, $a2
2937         mov     $a1, 8*1($r_ptr)
2938         cmovnc  $t3, $a3
2939         mov     $a2, 8*2($r_ptr)
2940         mov     $a3, 8*3($r_ptr)
2941
2942         ret
2943 .size   __ecp_nistz256_add_tox,.-__ecp_nistz256_add_tox
2944
2945 .type   __ecp_nistz256_sub_fromx,\@abi-omnipotent
2946 .align  32
2947 __ecp_nistz256_sub_fromx:
2948         xor     $t4, $t4
2949         sbb     8*0($b_ptr), $a0
2950         sbb     8*1($b_ptr), $a1
2951          mov    $a0, $t0
2952         sbb     8*2($b_ptr), $a2
2953         sbb     8*3($b_ptr), $a3
2954          mov    $a1, $t1
2955         sbb     \$0, $t4
2956
2957         xor     $t3, $t3
2958         adc     \$-1, $a0
2959          mov    $a2, $t2
2960         adc     $poly1, $a1
2961         adc     \$0, $a2
2962          mov    $a3, $t3
2963         adc     $poly3, $a3
2964
2965         bt      \$0, $t4
2966         cmovnc  $t0, $a0
2967         cmovnc  $t1, $a1
2968         mov     $a0, 8*0($r_ptr)
2969         cmovnc  $t2, $a2
2970         mov     $a1, 8*1($r_ptr)
2971         cmovnc  $t3, $a3
2972         mov     $a2, 8*2($r_ptr)
2973         mov     $a3, 8*3($r_ptr)
2974
2975         ret
2976 .size   __ecp_nistz256_sub_fromx,.-__ecp_nistz256_sub_fromx
2977
2978 .type   __ecp_nistz256_subx,\@abi-omnipotent
2979 .align  32
2980 __ecp_nistz256_subx:
2981         xor     $t4, $t4
2982         sbb     $a0, $t0
2983         sbb     $a1, $t1
2984          mov    $t0, $a0
2985         sbb     $a2, $t2
2986         sbb     $a3, $t3
2987          mov    $t1, $a1
2988         sbb     \$0, $t4
2989
2990         xor     $a3 ,$a3
2991         adc     \$-1, $t0
2992          mov    $t2, $a2
2993         adc     $poly1, $t1
2994         adc     \$0, $t2
2995          mov    $t3, $a3
2996         adc     $poly3, $t3
2997
2998         bt      \$0, $t4
2999         cmovc   $t0, $a0
3000         cmovc   $t1, $a1
3001         cmovc   $t2, $a2
3002         cmovc   $t3, $a3
3003
3004         ret
3005 .size   __ecp_nistz256_subx,.-__ecp_nistz256_subx
3006
3007 .type   __ecp_nistz256_mul_by_2x,\@abi-omnipotent
3008 .align  32
3009 __ecp_nistz256_mul_by_2x:
3010         xor     $t4, $t4
3011         adc     $a0, $a0                # a0:a3+a0:a3
3012         adc     $a1, $a1
3013          mov    $a0, $t0
3014         adc     $a2, $a2
3015         adc     $a3, $a3
3016          mov    $a1, $t1
3017         adc     \$0, $t4
3018
3019         xor     $t3, $t3
3020         sbb     \$-1, $a0
3021          mov    $a2, $t2
3022         sbb     $poly1, $a1
3023         sbb     \$0, $a2
3024          mov    $a3, $t3
3025         sbb     $poly3, $a3
3026
3027         bt      \$0, $t4
3028         cmovnc  $t0, $a0
3029         cmovnc  $t1, $a1
3030         mov     $a0, 8*0($r_ptr)
3031         cmovnc  $t2, $a2
3032         mov     $a1, 8*1($r_ptr)
3033         cmovnc  $t3, $a3
3034         mov     $a2, 8*2($r_ptr)
3035         mov     $a3, 8*3($r_ptr)
3036
3037         ret
3038 .size   __ecp_nistz256_mul_by_2x,.-__ecp_nistz256_mul_by_2x
3039 ___
3040                                                                         }
3041 &gen_double("x");
3042 &gen_add("x");
3043 &gen_add_affine("x");
3044 }
3045 }}}
3046
3047 ########################################################################
3048 # Convert ecp_nistz256_table.c to layout expected by ecp_nistz_gather_w7
3049 #
3050 open TABLE,"<ecp_nistz256_table.c"              or 
3051 open TABLE,"<${dir}../ecp_nistz256_table.c"     or 
3052 die "failed to open ecp_nistz256_table.c:",$!;
3053
3054 use integer;
3055
3056 foreach(<TABLE>) {
3057         s/TOBN\(\s*(0x[0-9a-f]+),\s*(0x[0-9a-f]+)\s*\)/push @arr,hex($2),hex($1)/geo;
3058 }
3059 close TABLE;
3060
3061 die "insane number of elements" if ($#arr != 64*16*37-1);
3062
3063 print <<___;
3064 .text
3065 .globl  ecp_nistz256_precomputed
3066 .type   ecp_nistz256_precomputed,\@object
3067 .align  4096
3068 ecp_nistz256_precomputed:
3069 ___
3070 while (@line=splice(@arr,0,16)) {
3071         print ".long\t",join(',',map { sprintf "0x%08x",$_} @line),"\n";
3072 }
3073 print <<___;
3074 .size   ecp_nistz256_precomputed,.-ecp_nistz256_precomputed
3075 ___
3076
3077 $code =~ s/\`([^\`]*)\`/eval $1/gem;
3078 print $code;
3079 close STDOUT;