ed844636971247dd3b1760dc8fd5f0384ef9b752
[openssl.git] / crypto / bn / asm / rsaz-x86_64.pl
1 #!/usr/bin/env perl
2
3 #******************************************************************************#
4 #* Copyright(c) 2012, Intel Corp.                                             *#
5 #* Developers and authors:                                                    *#
6 #* Shay Gueron (1, 2), and Vlad Krasnov (1)                                   *#
7 #* (1) Intel Architecture Group, Microprocessor and Chipset Development,      *#
8 #*     Israel Development Center, Haifa, Israel                               *#
9 #* (2) University of Haifa                                                    *#
10 #******************************************************************************#
11 #* This submission to OpenSSL is to be made available under the OpenSSL       *#
12 #* license, and only to the OpenSSL project, in order to allow integration    *#
13 #* into the publicly distributed code. ?                                      *#
14 #* The use of this code, or portions of this code, or concepts embedded in    *#
15 #* this code, or modification of this code and/or algorithm(s) in it, or the  *#
16 #* use of this code for any other purpose than stated above, requires special *#
17 #* licensing.                                                                 *#
18 #******************************************************************************#
19 #******************************************************************************#
20 #* DISCLAIMER:                                                                *#
21 #* THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS AND THE COPYRIGHT OWNERS     *#
22 #* ``AS IS''. ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED *#
23 #* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR *#
24 #* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS OR THE COPYRIGHT*#
25 #* OWNERS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, *#
26 #* OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF    *#
27 #* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS   *#
28 #* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN    *#
29 #* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)    *#
30 #* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE *#
31 #* POSSIBILITY OF SUCH DAMAGE.                                                *#
32 #******************************************************************************#
33 #* Reference:                                                                 *#
34 #* [1] S. Gueron, "Efficient Software Implementations of Modular              *#
35 #*     Exponentiation", http://eprint.iacr.org/2011/239                       *#
36 #* [2] S. Gueron, V. Krasnov. "Speeding up Big-Numbers Squaring".             *#
37 #*     IEEE Proceedings of 9th International Conference on Information        *#
38 #*     Technology: New Generations (ITNG 2012), 821-823 (2012).               *#
39 #* [3] S. Gueron, Efficient Software Implementations of Modular Exponentiation*#
40 #*     Journal of Cryptographic Engineering 2:31-43 (2012).                   *#
41 #* [4] S. Gueron, V. Krasnov: "[PATCH] Efficient and side channel analysis    *#
42 #*     resistant 512-bit and 1024-bit modular exponentiation for optimizing   *#
43 #*     RSA1024 and RSA2048 on x86_64 platforms",                              *#
44 #*     http://rt.openssl.org/Ticket/Display.html?id=2582&user=guest&pass=guest*#
45 ################################################################################
46
47 # While original submission covers 512- and 1024-bit exponentiation,
48 # this module is limited to 512-bit version only (and as such
49 # accelerates RSA1024 sign). This is because improvement for longer
50 # keys is not high enough to justify the effort, highest measured
51 # was ~5% on Westmere. [This is relative to OpenSSL 1.0.2, upcoming
52 # for the moment of this writing!] Nor does this module implement
53 # "monolithic" complete exponentiation jumbo-subroutine, but adheres
54 # to more modular mixture of C and assembly. And it's optimized even
55 # for processors other than Intel Core family (see table below for
56 # improvement coefficients).
57 #                                               <appro@openssl.org>
58 #
59 # RSA1024 sign/sec      this/original   |this/rsax(*)   this/fips(*)
60 #                       ----------------+---------------------------
61 # Opteron               +13%            |+5%            +20%
62 # Bulldozer             -0%             |-1%            +10%
63 # P4                    +11%            |+7%            +8%
64 # Westmere              +5%             |+14%           +17%
65 # Sandy Bridge          +2%             |+12%           +29%
66 # Ivy Bridge            +1%             |+11%           +35%
67 # Haswell(**)           -0%             |+12%           +39%
68 # Atom                  +13%            |+11%           +4%
69 # VIA Nano              +70%            |+9%            +25%
70 #
71 # (*)   rsax engine and fips numbers are presented for reference
72 #       purposes;
73 # (**)  you might notice MULX code below, strangely enough gain is
74 #       marginal, which is why code remains disabled;
75
76 $flavour = shift;
77 $output  = shift;
78 if ($flavour =~ /\./) { $output = $flavour; undef $flavour; }
79
80 $win64=0; $win64=1 if ($flavour =~ /[nm]asm|mingw64/ || $output =~ /\.asm$/);
81
82 $0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1;
83 ( $xlate="${dir}x86_64-xlate.pl" and -f $xlate ) or
84 ( $xlate="${dir}../../perlasm/x86_64-xlate.pl" and -f $xlate) or
85 die "can't locate x86_64-xlate.pl";
86
87 open OUT,"| $^X $xlate $flavour $output";
88 *STDOUT=*OUT;
89
90 ($out, $inp, $mod) = ("%rdi", "%rsi", "%rbp");  # common internal API
91 {
92 my ($out,$inp,$mod,$n0,$times) = ("%rdi","%rsi","%rdx","%rcx","%r8d");
93
94 $code.=<<___;
95 .text
96
97 .globl  rsaz_512_sqr
98 .type   rsaz_512_sqr,\@function,4
99 .align  32
100 rsaz_512_sqr:                           # 25-29% faster than rsaz_512_mul
101         push    %rbx
102         push    %rbp
103         push    %r12
104         push    %r13
105         push    %r14
106         push    %r15
107
108         subq    \$128+24, %rsp
109 .Lsqr_body:
110         movq    $mod, %rbp              # common argument
111         movq    ($inp), %rdx
112         movq    8($inp), %rax
113         movq    $n0, 128(%rsp)
114         jmp     .Loop_sqr
115
116 .align  32
117 .Loop_sqr:
118         movl    $times,128+8(%rsp)
119 ___
120 if (1) {
121 $code.=<<___;
122 #first iteration
123         movq    %rdx, %rbx
124         mulq    %rdx
125         movq    %rax, %r8
126         movq    16($inp), %rax
127         movq    %rdx, %r9
128
129         mulq    %rbx
130         addq    %rax, %r9
131         movq    24($inp), %rax
132         movq    %rdx, %r10
133         adcq    \$0, %r10
134
135         mulq    %rbx
136         addq    %rax, %r10
137         movq    32($inp), %rax
138         movq    %rdx, %r11
139         adcq    \$0, %r11
140
141         mulq    %rbx
142         addq    %rax, %r11
143         movq    40($inp), %rax
144         movq    %rdx, %r12
145         adcq    \$0, %r12
146
147         mulq    %rbx
148         addq    %rax, %r12
149         movq    48($inp), %rax
150         movq    %rdx, %r13
151         adcq    \$0, %r13
152
153         mulq    %rbx
154         addq    %rax, %r13
155         movq    56($inp), %rax
156         movq    %rdx, %r14
157         adcq    \$0, %r14
158
159         mulq    %rbx
160         addq    %rax, %r14
161         movq    %rbx, %rax
162         movq    %rdx, %r15
163         adcq    \$0, %r15
164
165         addq    %r8, %r8                #shlq   \$1, %r8
166         movq    %r9, %rcx
167         adcq    %r9, %r9                #shld   \$1, %r8, %r9
168
169         mulq    %rax
170         movq    %rax, (%rsp)
171         addq    %rdx, %r8
172         adcq    \$0, %r9
173
174         movq    %r8, 8(%rsp)
175         shrq    \$63, %rcx
176
177 #second iteration
178         movq    8($inp), %r8
179         movq    16($inp), %rax
180         mulq    %r8
181         addq    %rax, %r10
182         movq    24($inp), %rax
183         movq    %rdx, %rbx
184         adcq    \$0, %rbx
185
186         mulq    %r8
187         addq    %rax, %r11
188         movq    32($inp), %rax
189         adcq    \$0, %rdx
190         addq    %rbx, %r11
191         movq    %rdx, %rbx
192         adcq    \$0, %rbx
193
194         mulq    %r8
195         addq    %rax, %r12
196         movq    40($inp), %rax
197         adcq    \$0, %rdx
198         addq    %rbx, %r12
199         movq    %rdx, %rbx
200         adcq    \$0, %rbx
201
202         mulq    %r8
203         addq    %rax, %r13
204         movq    48($inp), %rax
205         adcq    \$0, %rdx
206         addq    %rbx, %r13
207         movq    %rdx, %rbx
208         adcq    \$0, %rbx
209
210         mulq    %r8
211         addq    %rax, %r14
212         movq    56($inp), %rax
213         adcq    \$0, %rdx
214         addq    %rbx, %r14
215         movq    %rdx, %rbx
216         adcq    \$0, %rbx
217
218         mulq    %r8
219         addq    %rax, %r15
220         movq    %r8, %rax
221         adcq    \$0, %rdx
222         addq    %rbx, %r15
223         movq    %rdx, %r8
224         movq    %r10, %rdx
225         adcq    \$0, %r8
226
227         add     %rdx, %rdx
228         lea     (%rcx,%r10,2), %r10     #shld   \$1, %rcx, %r10
229         movq    %r11, %rbx
230         adcq    %r11, %r11              #shld   \$1, %r10, %r11
231
232         mulq    %rax
233         addq    %rax, %r9
234         adcq    %rdx, %r10
235         adcq    \$0, %r11
236
237         movq    %r9, 16(%rsp)
238         movq    %r10, 24(%rsp)
239         shrq    \$63, %rbx
240         
241 #third iteration
242         movq    16($inp), %r9   
243         movq    24($inp), %rax
244         mulq    %r9
245         addq    %rax, %r12
246         movq    32($inp), %rax
247         movq    %rdx, %rcx
248         adcq    \$0, %rcx
249
250         mulq    %r9
251         addq    %rax, %r13
252         movq    40($inp), %rax
253         adcq    \$0, %rdx
254         addq    %rcx, %r13
255         movq    %rdx, %rcx
256         adcq    \$0, %rcx
257
258         mulq    %r9
259         addq    %rax, %r14
260         movq    48($inp), %rax
261         adcq    \$0, %rdx
262         addq    %rcx, %r14
263         movq    %rdx, %rcx
264         adcq    \$0, %rcx
265
266         mulq    %r9
267          movq   %r12, %r10
268          lea    (%rbx,%r12,2), %r12     #shld   \$1, %rbx, %r12
269         addq    %rax, %r15
270         movq    56($inp), %rax
271         adcq    \$0, %rdx
272         addq    %rcx, %r15
273         movq    %rdx, %rcx
274         adcq    \$0, %rcx
275
276         mulq    %r9
277          shrq   \$63, %r10
278         addq    %rax, %r8
279         movq    %r9, %rax
280         adcq    \$0, %rdx
281         addq    %rcx, %r8
282         movq    %rdx, %r9
283         adcq    \$0, %r9
284
285         movq    %r13, %rcx
286         leaq    (%r10,%r13,2), %r13     #shld   \$1, %r12, %r13
287
288         mulq    %rax
289         addq    %rax, %r11
290         adcq    %rdx, %r12
291         adcq    \$0, %r13
292
293         movq    %r11, 32(%rsp)
294         movq    %r12, 40(%rsp)
295         shrq    \$63, %rcx
296
297 #fourth iteration
298         movq    24($inp), %r10
299         movq    32($inp), %rax
300         mulq    %r10
301         addq    %rax, %r14
302         movq    40($inp), %rax
303         movq    %rdx, %rbx
304         adcq    \$0, %rbx
305
306         mulq    %r10
307         addq    %rax, %r15
308         movq    48($inp), %rax
309         adcq    \$0, %rdx
310         addq    %rbx, %r15
311         movq    %rdx, %rbx
312         adcq    \$0, %rbx
313
314         mulq    %r10
315          movq   %r14, %r12
316          leaq   (%rcx,%r14,2), %r14     #shld   \$1, %rcx, %r14
317         addq    %rax, %r8
318         movq    56($inp), %rax
319         adcq    \$0, %rdx
320         addq    %rbx, %r8
321         movq    %rdx, %rbx
322         adcq    \$0, %rbx
323
324         mulq    %r10
325          shrq   \$63, %r12
326         addq    %rax, %r9
327         movq    %r10, %rax
328         adcq    \$0, %rdx
329         addq    %rbx, %r9
330         movq    %rdx, %r10
331         adcq    \$0, %r10
332
333         movq    %r15, %rbx
334         leaq    (%r12,%r15,2),%r15      #shld   \$1, %r14, %r15
335
336         mulq    %rax
337         addq    %rax, %r13
338         adcq    %rdx, %r14
339         adcq    \$0, %r15
340
341         movq    %r13, 48(%rsp)
342         movq    %r14, 56(%rsp)
343         shrq    \$63, %rbx
344
345 #fifth iteration
346         movq    32($inp), %r11
347         movq    40($inp), %rax
348         mulq    %r11
349         addq    %rax, %r8
350         movq    48($inp), %rax
351         movq    %rdx, %rcx
352         adcq    \$0, %rcx
353
354         mulq    %r11
355         addq    %rax, %r9
356         movq    56($inp), %rax
357         adcq    \$0, %rdx
358          movq   %r8, %r12
359          leaq   (%rbx,%r8,2), %r8       #shld   \$1, %rbx, %r8
360         addq    %rcx, %r9
361         movq    %rdx, %rcx
362         adcq    \$0, %rcx
363
364         mulq    %r11
365          shrq   \$63, %r12
366         addq    %rax, %r10
367         movq    %r11, %rax
368         adcq    \$0, %rdx
369         addq    %rcx, %r10
370         movq    %rdx, %r11
371         adcq    \$0, %r11
372
373         movq    %r9, %rcx
374         leaq    (%r12,%r9,2), %r9       #shld   \$1, %r8, %r9
375
376         mulq    %rax
377         addq    %rax, %r15
378         adcq    %rdx, %r8
379         adcq    \$0, %r9
380
381         movq    %r15, 64(%rsp)
382         movq    %r8, 72(%rsp)
383         shrq    \$63, %rcx
384
385 #sixth iteration
386         movq    40($inp), %r12
387         movq    48($inp), %rax
388         mulq    %r12
389         addq    %rax, %r10
390         movq    56($inp), %rax
391         movq    %rdx, %rbx
392         adcq    \$0, %rbx
393
394         mulq    %r12
395         addq    %rax, %r11
396         movq    %r12, %rax
397          movq   %r10, %r15
398          leaq   (%rcx,%r10,2), %r10     #shld   \$1, %rcx, %r10
399         adcq    \$0, %rdx
400          shrq   \$63, %r15
401         addq    %rbx, %r11
402         movq    %rdx, %r12
403         adcq    \$0, %r12
404
405         movq    %r11, %rbx
406         leaq    (%r15,%r11,2), %r11     #shld   \$1, %r10, %r11
407
408         mulq    %rax
409         addq    %rax, %r9
410         adcq    %rdx, %r10
411         adcq    \$0, %r11
412
413         movq    %r9, 80(%rsp)
414         movq    %r10, 88(%rsp)
415
416 #seventh iteration
417         movq    48($inp), %r13
418         movq    56($inp), %rax
419         mulq    %r13
420         addq    %rax, %r12
421         movq    %r13, %rax
422         movq    %rdx, %r13
423         adcq    \$0, %r13
424
425         xorq    %r14, %r14
426         shlq    \$1, %rbx
427         adcq    %r12, %r12              #shld   \$1, %rbx, %r12
428         adcq    %r13, %r13              #shld   \$1, %r12, %r13
429         adcq    %r14, %r14              #shld   \$1, %r13, %r14
430
431         mulq    %rax
432         addq    %rax, %r11
433         adcq    %rdx, %r12
434         adcq    \$0, %r13
435
436         movq    %r11, 96(%rsp)
437         movq    %r12, 104(%rsp)
438
439 #eighth iteration
440         movq    56($inp), %rax
441         mulq    %rax
442         addq    %rax, %r13
443         adcq    \$0, %rdx
444
445         addq    %rdx, %r14
446
447         movq    %r13, 112(%rsp)
448         movq    %r14, 120(%rsp)
449 ___
450 } else {
451 $code.=<<___;
452         movq    $out, %xmm0             # off-load
453 #first iteration        
454         mulx    %rax, %r8, %r9
455
456         mulx    16($inp), %rcx, %r10
457
458         mulx    24($inp), %rax, %r11
459         add     %rcx, %r9
460
461         mulx    32($inp), %rcx, %r12
462         adc     %rax, %r10
463
464         mulx    40($inp), %rax, %r13
465         adc     %rcx, %r11
466
467         mulx    48($inp), %rcx, %r14
468         adc     %rax, %r12
469
470         mulx    56($inp), %rax, %r15
471         adc     %rcx, %r13
472         mov     %r9, %rcx
473         adc     %rax, %r14
474         adc     \$0, %r15
475
476         shld    \$1, %r8, %r9
477         shl     \$1, %r8
478
479         mulx    %rdx, %rax, %rdx
480         add     %rdx, %r8
481         adc     \$0, %r9
482
483         mov     %rax, (%rsp)
484         mov     %r8, 8(%rsp)
485
486 #second iteration       
487         mov     8($inp), %rdx
488         mulx    16($inp), %rax, %rbx
489
490         mulx    24($inp), $out, %r8
491         add     %rax, %r10
492         adc     %rbx, %r11
493         adc     \$0, %r8
494
495         mulx    32($inp), %rax, %rbx
496         add     $out, %r11
497         adc     %r8, %r12
498         adc     \$0, %rbx
499
500         mulx    40($inp), $out, %r8
501         add     %rax, %r12
502         adc     %rbx, %r13
503         adc     \$0, %r8
504
505         mulx    48($inp), %rax, %rbx
506         add     $out, %r13
507         adc     %r8, %r14
508         adc     \$0, %rbx
509
510         mulx    56($inp), $out, %r8
511         add     %rax, %r14
512         adc     %rbx, %r15
513         mov     %r11, %rbx
514         adc     \$0, %r8
515         add     $out, %r15
516         adc     \$0, %r8
517
518         shld    \$1, %r10, %r11
519         shld    \$1, %rcx, %r10
520
521         mulx    %rdx, %rax, %rcx
522         add     %rax, %r9
523         adc     %rcx, %r10
524         adc     \$0, %r11
525
526         mov     %r9, 16(%rsp)
527         mov     %r10, 24(%rsp)
528         
529 #third iteration        
530         mov     16($inp), %rdx
531         mulx    24($inp), $out, %r9
532
533         mulx    32($inp), %rax, %rcx
534         add     $out, %r12
535         adc     %r9, %r13
536         adc     \$0, %rcx
537
538         mulx    40($inp), $out, %r9
539         add     %rax, %r13
540         adc     %rcx, %r14
541         adc     \$0, %r9
542
543         mulx    48($inp), %rax, %rcx
544         add     $out, %r14
545         adc     %r9, %r15
546         adc     \$0, %rcx
547
548         mulx    56($inp), $out, %r9
549         add     %rax, %r15
550         adc     %rcx, %r8
551         mov     %r13, %rcx
552         adc     \$0, %r9
553         add     $out, %r8
554         adc     \$0, %r9
555
556         shld    \$1, %r12, %r13
557         shld    \$1, %rbx, %r12
558
559         mulx    %rdx, %rax, %rdx
560         add     %rax, %r11
561         adc     %rdx, %r12
562         adc     \$0, %r13
563
564         mov     %r11, 32(%rsp)
565         mov     %r12, 40(%rsp)
566         
567 #fourth iteration       
568         mov     24($inp), %rdx
569         mulx    32($inp), %rax, %rbx
570
571         mulx    40($inp), $out, %r10
572         add     %rax, %r14
573         adc     %rbx, %r15
574         adc     \$0, %r10
575
576         mulx    48($inp), %rax, %rbx
577         add     $out, %r15
578         adc     %r10, %r8
579         adc     \$0, %rbx
580
581         mulx    56($inp), $out, %r10
582         add     %rax, %r8
583         adc     \$0, %rbx
584         add     $out, %r9
585         adc     \$0, %r10
586         add     %rbx, %r9
587         mov     %r15, %rbx
588         adc     \$0, %r10
589
590         shld    \$1, %r14, %r15
591         shld    \$1, %rcx, %r14
592
593         mulx    %rdx, %rax, %rdx
594         add     %rax, %r13
595         adc     %rdx, %r14
596         adc     \$0, %r15
597
598         mov     %r13, 48(%rsp)
599         mov     %r14, 56(%rsp)
600         
601 #fifth iteration        
602         mov     32($inp), %rdx
603         mulx    40($inp), $out, %r11
604
605         mulx    48($inp), %rax, %rcx
606         add     $out, %r8
607         adc     %r11, %r9
608         adc     \$0, %rcx
609
610         mulx    56($inp), $out, %r11
611         add     %rax, %r9
612         adc     %rcx, %r10
613         adc     \$0, %r11
614         add     $out, %r10
615         adc     \$0, %r11
616
617         mov     %r9, %rcx
618         shld    \$1, %r8, %r9
619         shld    \$1, %rbx, %r8
620
621         mulx    %rdx, %rax, %rdx
622         add     %rax, %r15
623         adc     %rdx, %r8
624         adc     \$0, %r9
625
626         mov     %r15, 64(%rsp)
627         mov     %r8, 72(%rsp)
628         
629 #sixth iteration        
630         mov     40($inp), %rdx
631         mulx    48($inp), %rax, %rbx
632
633         mulx    56($inp), $out, %r12
634         add     %rax, %r10
635         adc     %rbx, %r11
636         adc     \$0, %r12
637         add     $out, %r11
638         adc     \$0, %r12
639
640         mov     %r11, %rbx
641         shld    \$1, %r10, %r11
642         shld    \$1, %rcx, %r10
643
644         mulx    %rdx, %rax, %rdx
645         add     %rax, %r9
646         adc     %rdx, %r10
647         adc     \$0, %r11
648
649         mov     %r9, 80(%rsp)
650         mov     %r10, 88(%rsp)
651
652 #seventh iteration
653         mov     48($inp), %rdx
654         mulx    56($inp), %rax, %r13
655         add     %rax, %r12
656         adc     \$0, %r13
657
658         xor     %r14, %r14
659         shld    \$1, %r13, %r14
660         shld    \$1, %r12, %r13
661         shld    \$1, %rbx, %r12
662
663         mulx    %rdx, %rax, %rdx
664         add     %rax, %r11
665         adc     %rdx, %r12
666         adc     \$0, %r13
667
668         mov     %r11, 96(%rsp)
669         mov     %r12, 104(%rsp)
670
671 #eighth iteration
672         mov     56($inp), %rdx
673         mulx    %rdx, %rax, %rdx
674         add     %rax, %r13
675         adc     \$0, %rdx
676         
677         add     %rdx, %r14
678
679         movq    %r13, 112(%rsp)
680         movq    %r14, 120(%rsp)
681         movq    %xmm0, $out
682 ___
683 }
684 $code.=<<___;
685         movq    (%rsp), %r8
686         movq    8(%rsp), %r9
687         movq    16(%rsp), %r10
688         movq    24(%rsp), %r11
689         movq    32(%rsp), %r12
690         movq    40(%rsp), %r13
691         movq    48(%rsp), %r14
692         movq    56(%rsp), %r15
693
694         call    _rsaz_512_reduce
695
696         addq    64(%rsp), %r8
697         adcq    72(%rsp), %r9
698         adcq    80(%rsp), %r10
699         adcq    88(%rsp), %r11
700         adcq    96(%rsp), %r12
701         adcq    104(%rsp), %r13
702         adcq    112(%rsp), %r14
703         adcq    120(%rsp), %r15
704         sbbq    %rcx, %rcx
705
706         call    _rsaz_512_subtract
707
708         movq    %r8, %rdx
709         movq    %r9, %rax
710         movl    128+8(%rsp), $times
711         movq    $out, $inp
712
713         decl    $times
714         jnz     .Loop_sqr
715
716         leaq    128+24+48(%rsp), %rax
717         movq    -48(%rax), %r15
718         movq    -40(%rax), %r14
719         movq    -32(%rax), %r13
720         movq    -24(%rax), %r12
721         movq    -16(%rax), %rbp
722         movq    -8(%rax), %rbx
723         leaq    (%rax), %rsp
724 .Lsqr_epilogue:
725         ret
726 .size   rsaz_512_sqr,.-rsaz_512_sqr
727 ___
728 }
729 {
730 my ($out,$ap,$bp,$mod,$n0) = ("%rdi","%rsi","%rdx","%rcx","%r8");
731 $code.=<<___;
732 .global rsaz_512_mul
733 .type   rsaz_512_mul,\@function,5
734 .align  32
735 rsaz_512_mul:
736         push    %rbx
737         push    %rbp
738         push    %r12
739         push    %r13
740         push    %r14
741         push    %r15
742
743         subq    \$128+24, %rsp
744 .Lmul_body:
745         movq    $out, %xmm0             # off-load arguments
746         movq    $mod, %xmm1
747         movq    $n0, 128(%rsp)
748
749         movq    $bp, %rbp               # pass argument
750         call    _rsaz_512_mul
751
752         movq    %xmm0, $out
753         movq    %xmm1, %rbp
754
755         movq    (%rsp), %r8
756         movq    8(%rsp), %r9
757         movq    16(%rsp), %r10
758         movq    24(%rsp), %r11
759         movq    32(%rsp), %r12
760         movq    40(%rsp), %r13
761         movq    48(%rsp), %r14
762         movq    56(%rsp), %r15
763
764         call    _rsaz_512_reduce
765
766         addq    64(%rsp), %r8
767         adcq    72(%rsp), %r9
768         adcq    80(%rsp), %r10
769         adcq    88(%rsp), %r11
770         adcq    96(%rsp), %r12
771         adcq    104(%rsp), %r13
772         adcq    112(%rsp), %r14
773         adcq    120(%rsp), %r15
774         sbbq    %rcx, %rcx
775
776         call    _rsaz_512_subtract
777
778         leaq    128+24+48(%rsp), %rax
779         movq    -48(%rax), %r15
780         movq    -40(%rax), %r14
781         movq    -32(%rax), %r13
782         movq    -24(%rax), %r12
783         movq    -16(%rax), %rbp
784         movq    -8(%rax), %rbx
785         leaq    (%rax), %rsp
786 .Lmul_epilogue:
787         ret
788 .size   rsaz_512_mul,.-rsaz_512_mul
789 ___
790 }
791 {
792 my ($out,$ap,$bp,$mod,$n0,$pwr) = ("%rdi","%rsi","%rdx","%rcx","%r8","%r9d");
793 $code.=<<___;
794 .global rsaz_512_mul_gather4
795 .type   rsaz_512_mul_gather4,\@function,6
796 .align  32
797 rsaz_512_mul_gather4:
798         push    %rbx
799         push    %rbp
800         push    %r12
801         push    %r13
802         push    %r14
803         push    %r15
804
805         subq    \$128+24, %rsp
806 .Lmul_gather4_body:
807         movl    64($bp,$pwr,4), %eax
808         movq    $out, %xmm0             # off-load arguments
809         movl    ($bp,$pwr,4), %ebx
810         movq    $mod, %xmm1
811         movq    $n0, 128(%rsp)
812
813         shlq    \$32, %rax
814         or      %rax, %rbx
815         movq    ($ap), %rax
816          movq   8($ap), %rcx
817          leaq   128($bp,$pwr,4), %rbp
818         mulq    %rbx                    # 0 iteration
819         movq    %rax, (%rsp)
820         movq    %rcx, %rax
821         movq    %rdx, %r8
822
823         mulq    %rbx
824          movd   (%rbp), %xmm4
825         addq    %rax, %r8
826         movq    16($ap), %rax
827         movq    %rdx, %r9
828         adcq    \$0, %r9
829
830         mulq    %rbx
831          movd   64(%rbp), %xmm5
832         addq    %rax, %r9
833         movq    24($ap), %rax
834         movq    %rdx, %r10
835         adcq    \$0, %r10
836
837         mulq    %rbx
838          pslldq \$4, %xmm5
839         addq    %rax, %r10
840         movq    32($ap), %rax
841         movq    %rdx, %r11
842         adcq    \$0, %r11
843
844         mulq    %rbx
845          por    %xmm5, %xmm4
846         addq    %rax, %r11
847         movq    40($ap), %rax
848         movq    %rdx, %r12
849         adcq    \$0, %r12
850
851         mulq    %rbx
852         addq    %rax, %r12
853         movq    48($ap), %rax
854         movq    %rdx, %r13
855         adcq    \$0, %r13
856
857         mulq    %rbx
858          leaq   128(%rbp), %rbp
859         addq    %rax, %r13
860         movq    56($ap), %rax
861         movq    %rdx, %r14
862         adcq    \$0, %r14
863         
864         mulq    %rbx
865          movq   %xmm4, %rbx
866         addq    %rax, %r14
867          movq   ($ap), %rax
868         movq    %rdx, %r15
869         adcq    \$0, %r15
870
871         leaq    8(%rsp), %rdi
872         movl    \$7, %ecx
873         jmp     .Loop_mul_gather
874
875 .align  32
876 .Loop_mul_gather:
877         mulq    %rbx
878         addq    %rax, %r8
879         movq    8($ap), %rax
880         movq    %r8, (%rdi)
881         movq    %rdx, %r8
882         adcq    \$0, %r8
883
884         mulq    %rbx
885          movd   (%rbp), %xmm4
886         addq    %rax, %r9
887         movq    16($ap), %rax
888         adcq    \$0, %rdx
889         addq    %r9, %r8
890         movq    %rdx, %r9
891         adcq    \$0, %r9
892
893         mulq    %rbx
894          movd   64(%rbp), %xmm5
895         addq    %rax, %r10
896         movq    24($ap), %rax
897         adcq    \$0, %rdx
898         addq    %r10, %r9
899         movq    %rdx, %r10
900         adcq    \$0, %r10
901
902         mulq    %rbx
903          pslldq \$4, %xmm5
904         addq    %rax, %r11
905         movq    32($ap), %rax
906         adcq    \$0, %rdx
907         addq    %r11, %r10
908         movq    %rdx, %r11
909         adcq    \$0, %r11
910
911         mulq    %rbx
912          por    %xmm5, %xmm4
913         addq    %rax, %r12
914         movq    40($ap), %rax
915         adcq    \$0, %rdx
916         addq    %r12, %r11
917         movq    %rdx, %r12
918         adcq    \$0, %r12
919
920         mulq    %rbx
921         addq    %rax, %r13
922         movq    48($ap), %rax
923         adcq    \$0, %rdx
924         addq    %r13, %r12
925         movq    %rdx, %r13
926         adcq    \$0, %r13
927
928         mulq    %rbx
929         addq    %rax, %r14
930         movq    56($ap), %rax
931         adcq    \$0, %rdx
932         addq    %r14, %r13
933         movq    %rdx, %r14
934         adcq    \$0, %r14
935
936         mulq    %rbx
937          movq   %xmm4, %rbx
938         addq    %rax, %r15
939          movq   ($ap), %rax
940         adcq    \$0, %rdx
941         addq    %r15, %r14
942         movq    %rdx, %r15      
943         adcq    \$0, %r15
944
945         leaq    128(%rbp), %rbp
946         leaq    8(%rdi), %rdi
947
948         decl    %ecx
949         jnz     .Loop_mul_gather
950
951         movq    %r8, (%rdi)
952         movq    %r9, 8(%rdi)
953         movq    %r10, 16(%rdi)
954         movq    %r11, 24(%rdi)
955         movq    %r12, 32(%rdi)
956         movq    %r13, 40(%rdi)
957         movq    %r14, 48(%rdi)
958         movq    %r15, 56(%rdi)
959
960         movq    %xmm0, $out
961         movq    %xmm1, %rbp
962
963         movq    (%rsp), %r8
964         movq    8(%rsp), %r9
965         movq    16(%rsp), %r10
966         movq    24(%rsp), %r11
967         movq    32(%rsp), %r12
968         movq    40(%rsp), %r13
969         movq    48(%rsp), %r14
970         movq    56(%rsp), %r15
971
972         call    _rsaz_512_reduce
973
974         addq    64(%rsp), %r8
975         adcq    72(%rsp), %r9
976         adcq    80(%rsp), %r10
977         adcq    88(%rsp), %r11
978         adcq    96(%rsp), %r12
979         adcq    104(%rsp), %r13
980         adcq    112(%rsp), %r14
981         adcq    120(%rsp), %r15
982         sbbq    %rcx, %rcx
983
984         call    _rsaz_512_subtract
985
986         leaq    128+24+48(%rsp), %rax
987         movq    -48(%rax), %r15
988         movq    -40(%rax), %r14
989         movq    -32(%rax), %r13
990         movq    -24(%rax), %r12
991         movq    -16(%rax), %rbp
992         movq    -8(%rax), %rbx
993         leaq    (%rax), %rsp
994 .Lmul_gather4_epilogue:
995         ret
996 .size   rsaz_512_mul_gather4,.-rsaz_512_mul_gather4
997 ___
998 }
999 {
1000 my ($out,$ap,$mod,$n0,$tbl,$pwr) = ("%rdi","%rsi","%rdx","%rcx","%r8","%r9d");
1001 $code.=<<___;
1002 .global rsaz_512_mul_scatter4
1003 .type   rsaz_512_mul_scatter4,\@function,6
1004 .align  32
1005 rsaz_512_mul_scatter4:
1006         push    %rbx
1007         push    %rbp
1008         push    %r12
1009         push    %r13
1010         push    %r14
1011         push    %r15
1012
1013         subq    \$128+24, %rsp
1014 .Lmul_scatter4_body:
1015         leaq    ($tbl,$pwr,4), $tbl
1016         movq    $out, %xmm0             # off-load arguments
1017         movq    $mod, %xmm1
1018         movq    $tbl, %xmm2
1019         movq    $n0, 128(%rsp)
1020
1021         movq    $out, %rbp
1022         call    _rsaz_512_mul
1023
1024         movq    %xmm0, $out
1025         movq    %xmm1, %rbp
1026
1027         movq    (%rsp), %r8
1028         movq    8(%rsp), %r9
1029         movq    16(%rsp), %r10
1030         movq    24(%rsp), %r11
1031         movq    32(%rsp), %r12
1032         movq    40(%rsp), %r13
1033         movq    48(%rsp), %r14
1034         movq    56(%rsp), %r15
1035
1036         call    _rsaz_512_reduce
1037
1038         addq    64(%rsp), %r8
1039         adcq    72(%rsp), %r9
1040         adcq    80(%rsp), %r10
1041         adcq    88(%rsp), %r11
1042         adcq    96(%rsp), %r12
1043         adcq    104(%rsp), %r13
1044         adcq    112(%rsp), %r14
1045         adcq    120(%rsp), %r15
1046         movq    %xmm2, $inp
1047         sbbq    %rcx, %rcx
1048
1049         call    _rsaz_512_subtract
1050
1051         movl    %r8d, 64*0($inp)        # scatter
1052         shrq    \$32, %r8
1053         movl    %r9d, 64*2($inp)
1054         shrq    \$32, %r9
1055         movl    %r10d, 64*4($inp)
1056         shrq    \$32, %r10
1057         movl    %r11d, 64*6($inp)
1058         shrq    \$32, %r11
1059         movl    %r12d, 64*8($inp)
1060         shrq    \$32, %r12
1061         movl    %r13d, 64*10($inp)
1062         shrq    \$32, %r13
1063         movl    %r14d, 64*12($inp)
1064         shrq    \$32, %r14
1065         movl    %r15d, 64*14($inp)
1066         shrq    \$32, %r15
1067         movl    %r8d, 64*1($inp)
1068         movl    %r9d, 64*3($inp)
1069         movl    %r10d, 64*5($inp)
1070         movl    %r11d, 64*7($inp)
1071         movl    %r12d, 64*9($inp)
1072         movl    %r13d, 64*11($inp)
1073         movl    %r14d, 64*13($inp)
1074         movl    %r15d, 64*15($inp)
1075
1076         leaq    128+24+48(%rsp), %rax
1077         movq    -48(%rax), %r15
1078         movq    -40(%rax), %r14
1079         movq    -32(%rax), %r13
1080         movq    -24(%rax), %r12
1081         movq    -16(%rax), %rbp
1082         movq    -8(%rax), %rbx
1083         leaq    (%rax), %rsp
1084 .Lmul_scatter4_epilogue:
1085         ret
1086 .size   rsaz_512_mul_scatter4,.-rsaz_512_mul_scatter4
1087 ___
1088 }
1089 {
1090 my ($out,$inp,$mod,$n0) = ("%rdi","%rsi","%rdx","%rcx");
1091 $code.=<<___;
1092 .globl  rsaz_512_mul_by_one
1093 .type   rsaz_512_mul_by_one,\@function,4
1094 .align  32
1095 rsaz_512_mul_by_one:
1096         push    %rbx
1097         push    %rbp
1098         push    %r12
1099         push    %r13
1100         push    %r14
1101         push    %r15
1102
1103         subq    \$128+24, %rsp
1104 .Lmul_by_one_body:
1105         movq    $mod, %rbp      # reassign argument
1106         movq    $n0, 128(%rsp)
1107
1108         movq    ($inp), %r8
1109         pxor    %xmm0, %xmm0
1110         movq    8($inp), %r9
1111         movq    16($inp), %r10
1112         movq    24($inp), %r11
1113         movq    32($inp), %r12
1114         movq    40($inp), %r13
1115         movq    48($inp), %r14
1116         movq    56($inp), %r15
1117
1118         movdqa  %xmm0, (%rsp)
1119         movdqa  %xmm0, 16(%rsp)
1120         movdqa  %xmm0, 32(%rsp)
1121         movdqa  %xmm0, 48(%rsp)
1122         movdqa  %xmm0, 64(%rsp)
1123         movdqa  %xmm0, 80(%rsp)
1124         movdqa  %xmm0, 96(%rsp)
1125
1126         call    _rsaz_512_reduce
1127
1128         movq    %r8, ($out)
1129         movq    %r9, 8($out)
1130         movq    %r10, 16($out)
1131         movq    %r11, 24($out)
1132         movq    %r12, 32($out)
1133         movq    %r13, 40($out)
1134         movq    %r14, 48($out)
1135         movq    %r15, 56($out)
1136
1137         leaq    128+24+48(%rsp), %rax
1138         movq    -48(%rax), %r15
1139         movq    -40(%rax), %r14
1140         movq    -32(%rax), %r13
1141         movq    -24(%rax), %r12
1142         movq    -16(%rax), %rbp
1143         movq    -8(%rax), %rbx
1144         leaq    (%rax), %rsp
1145 .Lmul_by_one_epilogue:
1146         ret
1147 .size   rsaz_512_mul_by_one,.-rsaz_512_mul_by_one
1148 ___
1149 }
1150 {       # _rsaz_512_reduce
1151         #
1152         # input:        %r8-%r15, %rbp - mod, 128(%rsp) - n0
1153         # output:       %r8-%r15
1154         # clobbers:     everything except %rbp and %rdi
1155 $code.=<<___;
1156 .type   _rsaz_512_reduce,\@abi-omnipotent
1157 .align  32
1158 _rsaz_512_reduce:
1159 ___
1160 if (1) {
1161 $code.=<<___;
1162         movq    %r8, %rbx
1163         imulq   128+8(%rsp), %rbx
1164         movq    0(%rbp), %rax
1165         movl    \$8, %ecx
1166         jmp     .Lreduction_loop
1167
1168 .align  32
1169 .Lreduction_loop:
1170         mulq    %rbx
1171         movq    8(%rbp), %rax
1172         negq    %r8
1173         movq    %rdx, %r8
1174         adcq    \$0, %r8
1175
1176         mulq    %rbx
1177         addq    %rax, %r9
1178         movq    16(%rbp), %rax
1179         adcq    \$0, %rdx
1180         addq    %r9, %r8
1181         movq    %rdx, %r9
1182         adcq    \$0, %r9
1183
1184         mulq    %rbx
1185         addq    %rax, %r10
1186         movq    24(%rbp), %rax
1187         adcq    \$0, %rdx
1188         addq    %r10, %r9
1189         movq    %rdx, %r10
1190         adcq    \$0, %r10
1191
1192         mulq    %rbx
1193         addq    %rax, %r11
1194         movq    32(%rbp), %rax
1195         adcq    \$0, %rdx
1196         addq    %r11, %r10
1197          movq   128+8(%rsp), %rsi
1198         movq    %rdx, %r11
1199         adcq    \$0, %r11
1200
1201         mulq    %rbx
1202         addq    %rax, %r12
1203         movq    40(%rbp), %rax
1204         adcq    \$0, %rdx
1205          imulq  %r8, %rsi
1206         addq    %r12, %r11
1207         movq    %rdx, %r12
1208         adcq    \$0, %r12
1209
1210         mulq    %rbx
1211         addq    %rax, %r13
1212         movq    48(%rbp), %rax
1213         adcq    \$0, %rdx
1214         addq    %r13, %r12
1215         movq    %rdx, %r13
1216         adcq    \$0, %r13
1217
1218         mulq    %rbx
1219         addq    %rax, %r14
1220         movq    56(%rbp), %rax
1221         adcq    \$0, %rdx
1222         addq    %r14, %r13
1223         movq    %rdx, %r14
1224         adcq    \$0, %r14
1225
1226         mulq    %rbx
1227          movq   %rsi, %rbx
1228         addq    %rax, %r15
1229          movq   0(%rbp), %rax
1230         adcq    \$0, %rdx
1231         addq    %r15, %r14
1232         movq    %rdx, %r15
1233         adcq    \$0, %r15
1234
1235         decl    %ecx
1236         jne     .Lreduction_loop
1237 ___
1238 } else {
1239 $code.=<<___;
1240         movq    128+8(%rsp), %rdx               # pull $n0
1241         imulq   %r8, %rdx
1242         movl    \$8, %ecx
1243         jmp     .Lreduction_loop
1244
1245 .align  32
1246 .Lreduction_loop:
1247         neg     %r8
1248         mulx    0(%rbp), %rax, %r8
1249         adc     %r9, %r8
1250
1251         mulx    8(%rbp), %rax, %r9
1252         adc     \$0, %r9
1253         add     %rax, %r8
1254         adc     %r10, %r9
1255
1256         mulx    16(%rbp), %rax, %r10
1257         adc     \$0, %r10
1258          mov    128+8(%rsp), %rbx               # pull $n0
1259          imul   %r8, %rbx
1260         add     %rax, %r9
1261         adc     %r11, %r10
1262
1263         mulx    24(%rbp), %rax, %r11
1264         adc     \$0, %r11
1265         add     %rax, %r10
1266         adc     %r12, %r11
1267
1268         mulx    32(%rbp), %rax, %r12
1269         adc     \$0, %r12
1270         add     %rax, %r11
1271         adc     %r13, %r12
1272
1273         mulx    40(%rbp), %rax, %r13
1274         adc     \$0, %r13
1275         add     %rax, %r12
1276         adc     %r14, %r13
1277
1278         mulx    48(%rbp), %rax, %r14
1279         adc     \$0, %r14
1280         add     %rax, %r13
1281         adc     %r15, %r14
1282
1283         mulx    56(%rbp), %rax, %r15
1284          mov    %rbx, %rdx
1285         adc     \$0, %r15
1286         add     %rax, %r14
1287         adc     \$0, %r15
1288
1289         dec     %ecx
1290         jne     .Lreduction_loop
1291 ___
1292 }
1293 $code.=<<___;
1294         ret
1295 .size   _rsaz_512_reduce,.-_rsaz_512_reduce
1296 ___
1297 }
1298 {       # _rsaz_512_subtract
1299         # input: %r8-%r15, %rdi - $out, %rbp - $mod, %rcx - mask
1300         # output:
1301         # clobbers: everything but %rdi, %rsi and %rbp
1302 $code.=<<___;
1303 .type   _rsaz_512_subtract,\@abi-omnipotent
1304 .align  32
1305 _rsaz_512_subtract:
1306         movq    %r8, ($out)
1307         movq    %r9, 8($out)
1308         movq    %r10, 16($out)
1309         movq    %r11, 24($out)
1310         movq    %r12, 32($out)
1311         movq    %r13, 40($out)
1312         movq    %r14, 48($out)
1313         movq    %r15, 56($out)
1314
1315         movq    0($mod), %r8
1316         movq    8($mod), %r9
1317         negq    %r8
1318         notq    %r9
1319         andq    %rcx, %r8
1320         movq    16($mod), %r10
1321         andq    %rcx, %r9
1322         notq    %r10
1323         movq    24($mod), %r11
1324         andq    %rcx, %r10
1325         notq    %r11
1326         movq    32($mod), %r12
1327         andq    %rcx, %r11
1328         notq    %r12
1329         movq    40($mod), %r13
1330         andq    %rcx, %r12
1331         notq    %r13
1332         movq    48($mod), %r14
1333         andq    %rcx, %r13
1334         notq    %r14
1335         movq    56($mod), %r15
1336         andq    %rcx, %r14
1337         notq    %r15
1338         andq    %rcx, %r15
1339
1340         addq    ($out), %r8
1341         adcq    8($out), %r9
1342         adcq    16($out), %r10
1343         adcq    24($out), %r11
1344         adcq    32($out), %r12
1345         adcq    40($out), %r13
1346         adcq    48($out), %r14
1347         adcq    56($out), %r15
1348
1349         movq    %r8, ($out)
1350         movq    %r9, 8($out)
1351         movq    %r10, 16($out)
1352         movq    %r11, 24($out)
1353         movq    %r12, 32($out)
1354         movq    %r13, 40($out)
1355         movq    %r14, 48($out)
1356         movq    %r15, 56($out)
1357
1358         ret
1359 .size   _rsaz_512_subtract,.-_rsaz_512_subtract
1360 ___
1361 }
1362 {       # _rsaz_512_mul
1363         #
1364         # input: %rsi - ap, %rbp - bp
1365         # ouput:
1366         # clobbers: everything
1367 my ($ap,$bp) = ("%rsi","%rbp");
1368 $code.=<<___;
1369 .type   _rsaz_512_mul,\@abi-omnipotent
1370 .align  32
1371 _rsaz_512_mul:
1372         leaq    8(%rsp), %rdi
1373
1374         movq    ($bp), %rbx
1375         movq    ($ap), %rax
1376         mulq    %rbx
1377         movq    %rax, (%rdi)
1378         movq    8($ap), %rax
1379         movq    %rdx, %r8
1380
1381         mulq    %rbx
1382         addq    %rax, %r8
1383         movq    16($ap), %rax
1384         movq    %rdx, %r9
1385         adcq    \$0, %r9
1386
1387         mulq    %rbx
1388         addq    %rax, %r9
1389         movq    24($ap), %rax
1390         movq    %rdx, %r10
1391         adcq    \$0, %r10
1392
1393         mulq    %rbx
1394         addq    %rax, %r10
1395         movq    32($ap), %rax
1396         movq    %rdx, %r11
1397         adcq    \$0, %r11
1398
1399         mulq    %rbx
1400         addq    %rax, %r11
1401         movq    40($ap), %rax
1402         movq    %rdx, %r12
1403         adcq    \$0, %r12
1404
1405         mulq    %rbx
1406         addq    %rax, %r12
1407         movq    48($ap), %rax
1408         movq    %rdx, %r13
1409         adcq    \$0, %r13
1410
1411         mulq    %rbx
1412         addq    %rax, %r13
1413         movq    56($ap), %rax
1414         movq    %rdx, %r14
1415         adcq    \$0, %r14
1416         
1417         mulq    %rbx
1418         addq    %rax, %r14
1419          movq   ($ap), %rax
1420         movq    %rdx, %r15
1421         adcq    \$0, %r15
1422
1423         leaq    8($bp), $bp
1424         leaq    8(%rdi), %rdi
1425
1426         movl    \$7, %ecx
1427         jmp     .Loop_mul
1428
1429 .align  32
1430 .Loop_mul:
1431         movq    ($bp), %rbx
1432         mulq    %rbx
1433         addq    %rax, %r8
1434         movq    8($ap), %rax
1435         movq    %r8, (%rdi)
1436         movq    %rdx, %r8
1437         adcq    \$0, %r8
1438
1439         mulq    %rbx
1440         addq    %rax, %r9
1441         movq    16($ap), %rax
1442         adcq    \$0, %rdx
1443         addq    %r9, %r8
1444         movq    %rdx, %r9
1445         adcq    \$0, %r9
1446
1447         mulq    %rbx
1448         addq    %rax, %r10
1449         movq    24($ap), %rax
1450         adcq    \$0, %rdx
1451         addq    %r10, %r9
1452         movq    %rdx, %r10
1453         adcq    \$0, %r10
1454
1455         mulq    %rbx
1456         addq    %rax, %r11
1457         movq    32($ap), %rax
1458         adcq    \$0, %rdx
1459         addq    %r11, %r10
1460         movq    %rdx, %r11
1461         adcq    \$0, %r11
1462
1463         mulq    %rbx
1464         addq    %rax, %r12
1465         movq    40($ap), %rax
1466         adcq    \$0, %rdx
1467         addq    %r12, %r11
1468         movq    %rdx, %r12
1469         adcq    \$0, %r12
1470
1471         mulq    %rbx
1472         addq    %rax, %r13
1473         movq    48($ap), %rax
1474         adcq    \$0, %rdx
1475         addq    %r13, %r12
1476         movq    %rdx, %r13
1477         adcq    \$0, %r13
1478
1479         mulq    %rbx
1480         addq    %rax, %r14
1481         movq    56($ap), %rax
1482         adcq    \$0, %rdx
1483         addq    %r14, %r13
1484         movq    %rdx, %r14
1485          leaq   8($bp), $bp
1486         adcq    \$0, %r14
1487
1488         mulq    %rbx
1489         addq    %rax, %r15
1490          movq   ($ap), %rax
1491         adcq    \$0, %rdx
1492         addq    %r15, %r14
1493         movq    %rdx, %r15      
1494         adcq    \$0, %r15
1495
1496         leaq    8(%rdi), %rdi
1497
1498         decl    %ecx
1499         jnz     .Loop_mul
1500
1501         movq    %r8, (%rdi)
1502         movq    %r9, 8(%rdi)
1503         movq    %r10, 16(%rdi)
1504         movq    %r11, 24(%rdi)
1505         movq    %r12, 32(%rdi)
1506         movq    %r13, 40(%rdi)
1507         movq    %r14, 48(%rdi)
1508         movq    %r15, 56(%rdi)
1509
1510         ret
1511 .size   _rsaz_512_mul,.-_rsaz_512_mul
1512 ___
1513 }
1514 {
1515 my ($out,$inp,$power)= $win64 ? ("%rcx","%rdx","%r8d") : ("%rdi","%rsi","%edx");
1516 $code.=<<___;
1517 .globl  rsaz_512_scatter4
1518 .type   rsaz_512_scatter4,\@abi-omnipotent
1519 .align  16
1520 rsaz_512_scatter4:
1521         leaq    ($out,$power,4), $out
1522         movl    \$8, %r9d
1523         jmp     .Loop_scatter
1524 .align  16
1525 .Loop_scatter:
1526         movq    ($inp), %rax
1527         leaq    8($inp), $inp
1528         movl    %eax, ($out)
1529         shrq    \$32, %rax
1530         movl    %eax, 64($out)
1531         leaq    128($out), $out
1532         decl    %r9d
1533         jnz     .Loop_scatter
1534         ret
1535 .size   rsaz_512_scatter4,.-rsaz_512_scatter4
1536
1537 .globl  rsaz_512_gather4
1538 .type   rsaz_512_gather4,\@abi-omnipotent
1539 .align  16
1540 rsaz_512_gather4:
1541         leaq    ($inp,$power,4), $inp
1542         movl    \$8, %r9d
1543         jmp     .Loop_gather
1544 .align  16
1545 .Loop_gather:
1546         movl    ($inp), %eax
1547         movl    64($inp), %r8d
1548         leaq    128($inp), $inp
1549         shlq    \$32, %r8
1550         or      %r8, %rax
1551         movq    %rax, ($out)
1552         leaq    8($out), $out
1553         decl    %r9d
1554         jnz     .Loop_gather
1555         ret
1556 .size   rsaz_512_gather4,.-rsaz_512_gather4
1557 ___
1558 }
1559
1560 # EXCEPTION_DISPOSITION handler (EXCEPTION_RECORD *rec,ULONG64 frame,
1561 #               CONTEXT *context,DISPATCHER_CONTEXT *disp)
1562 if ($win64) {
1563 $rec="%rcx";
1564 $frame="%rdx";
1565 $context="%r8";
1566 $disp="%r9";
1567
1568 $code.=<<___;
1569 .extern __imp_RtlVirtualUnwind
1570 .type   se_handler,\@abi-omnipotent
1571 .align  16
1572 se_handler:
1573         push    %rsi
1574         push    %rdi
1575         push    %rbx
1576         push    %rbp
1577         push    %r12
1578         push    %r13
1579         push    %r14
1580         push    %r15
1581         pushfq
1582         sub     \$64,%rsp
1583
1584         mov     120($context),%rax      # pull context->Rax
1585         mov     248($context),%rbx      # pull context->Rip
1586
1587         mov     8($disp),%rsi           # disp->ImageBase
1588         mov     56($disp),%r11          # disp->HandlerData
1589
1590         mov     0(%r11),%r10d           # HandlerData[0]
1591         lea     (%rsi,%r10),%r10        # end of prologue label
1592         cmp     %r10,%rbx               # context->Rip<end of prologue label
1593         jb      .Lcommon_seh_tail
1594
1595         mov     152($context),%rax      # pull context->Rsp
1596
1597         mov     4(%r11),%r10d           # HandlerData[1]
1598         lea     (%rsi,%r10),%r10        # epilogue label
1599         cmp     %r10,%rbx               # context->Rip>=epilogue label
1600         jae     .Lcommon_seh_tail
1601
1602         lea     128+24+48(%rax),%rax
1603
1604         mov     -8(%rax),%rbx
1605         mov     -16(%rax),%rbp
1606         mov     -24(%rax),%r12
1607         mov     -32(%rax),%r13
1608         mov     -40(%rax),%r14
1609         mov     -48(%rax),%r15
1610         mov     %rbx,144($context)      # restore context->Rbx
1611         mov     %rbp,160($context)      # restore context->Rbp
1612         mov     %r12,216($context)      # restore context->R12
1613         mov     %r13,224($context)      # restore context->R13
1614         mov     %r14,232($context)      # restore context->R14
1615         mov     %r15,240($context)      # restore context->R15
1616
1617 .Lcommon_seh_tail:
1618         mov     8(%rax),%rdi
1619         mov     16(%rax),%rsi
1620         mov     %rax,152($context)      # restore context->Rsp
1621         mov     %rsi,168($context)      # restore context->Rsi
1622         mov     %rdi,176($context)      # restore context->Rdi
1623
1624         mov     40($disp),%rdi          # disp->ContextRecord
1625         mov     $context,%rsi           # context
1626         mov     \$154,%ecx              # sizeof(CONTEXT)
1627         .long   0xa548f3fc              # cld; rep movsq
1628
1629         mov     $disp,%rsi
1630         xor     %rcx,%rcx               # arg1, UNW_FLAG_NHANDLER
1631         mov     8(%rsi),%rdx            # arg2, disp->ImageBase
1632         mov     0(%rsi),%r8             # arg3, disp->ControlPc
1633         mov     16(%rsi),%r9            # arg4, disp->FunctionEntry
1634         mov     40(%rsi),%r10           # disp->ContextRecord
1635         lea     56(%rsi),%r11           # &disp->HandlerData
1636         lea     24(%rsi),%r12           # &disp->EstablisherFrame
1637         mov     %r10,32(%rsp)           # arg5
1638         mov     %r11,40(%rsp)           # arg6
1639         mov     %r12,48(%rsp)           # arg7
1640         mov     %rcx,56(%rsp)           # arg8, (NULL)
1641         call    *__imp_RtlVirtualUnwind(%rip)
1642
1643         mov     \$1,%eax                # ExceptionContinueSearch
1644         add     \$64,%rsp
1645         popfq
1646         pop     %r15
1647         pop     %r14
1648         pop     %r13
1649         pop     %r12
1650         pop     %rbp
1651         pop     %rbx
1652         pop     %rdi
1653         pop     %rsi
1654         ret
1655 .size   sqr_handler,.-sqr_handler
1656
1657 .section        .pdata
1658 .align  4
1659         .rva    .LSEH_begin_rsaz_512_sqr
1660         .rva    .LSEH_end_rsaz_512_sqr
1661         .rva    .LSEH_info_rsaz_512_sqr
1662
1663         .rva    .LSEH_begin_rsaz_512_mul
1664         .rva    .LSEH_end_rsaz_512_mul
1665         .rva    .LSEH_info_rsaz_512_mul
1666
1667         .rva    .LSEH_begin_rsaz_512_mul_gather4
1668         .rva    .LSEH_end_rsaz_512_mul_gather4
1669         .rva    .LSEH_info_rsaz_512_mul_gather4
1670
1671         .rva    .LSEH_begin_rsaz_512_mul_scatter4
1672         .rva    .LSEH_end_rsaz_512_mul_scatter4
1673         .rva    .LSEH_info_rsaz_512_mul_scatter4
1674
1675         .rva    .LSEH_begin_rsaz_512_mul_by_one
1676         .rva    .LSEH_end_rsaz_512_mul_by_one
1677         .rva    .LSEH_info_rsaz_512_mul_by_one
1678
1679 .section        .xdata
1680 .align  8
1681 .LSEH_info_rsaz_512_sqr:
1682         .byte   9,0,0,0
1683         .rva    se_handler
1684         .rva    .Lsqr_body,.Lsqr_epilogue                       # HandlerData[]
1685 .LSEH_info_rsaz_512_mul:
1686         .byte   9,0,0,0
1687         .rva    se_handler
1688         .rva    .Lmul_body,.Lmul_epilogue                       # HandlerData[]
1689 .LSEH_info_rsaz_512_mul_gather4:
1690         .byte   9,0,0,0
1691         .rva    se_handler
1692         .rva    .Lmul_gather4_body,.Lmul_gather4_epilogue       # HandlerData[]
1693 .LSEH_info_rsaz_512_mul_scatter4:
1694         .byte   9,0,0,0
1695         .rva    se_handler
1696         .rva    .Lmul_scatter4_body,.Lmul_scatter4_epilogue     # HandlerData[]
1697 .LSEH_info_rsaz_512_mul_by_one:
1698         .byte   9,0,0,0
1699         .rva    se_handler
1700         .rva    .Lmul_by_one_body,.Lmul_by_one_epilogue         # HandlerData[]
1701 ___
1702 }
1703
1704 $code =~ s/\`([^\`]*)\`/eval $1/gem;
1705 print $code;
1706 close STDOUT;