bn/asm/rsaz-*.pl: allow spaces in Perl path name.
[openssl.git] / crypto / bn / asm / rsaz-x86_64.pl
1 #!/usr/bin/env perl
2
3 ##############################################################################
4 #                                                                            #
5 #  Copyright (c) 2012, Intel Corporation                                     #
6 #                                                                            #
7 #  All rights reserved.                                                      #
8 #                                                                            #
9 #  Redistribution and use in source and binary forms, with or without        #
10 #  modification, are permitted provided that the following conditions are    #
11 #  met:                                                                      #
12 #                                                                            #
13 #  *  Redistributions of source code must retain the above copyright         #
14 #     notice, this list of conditions and the following disclaimer.          #
15 #                                                                            #
16 #  *  Redistributions in binary form must reproduce the above copyright      #
17 #     notice, this list of conditions and the following disclaimer in the    #
18 #     documentation and/or other materials provided with the                 #
19 #     distribution.                                                          #
20 #                                                                            #
21 #  *  Neither the name of the Intel Corporation nor the names of its         #
22 #     contributors may be used to endorse or promote products derived from   #
23 #     this software without specific prior written permission.               #
24 #                                                                            #
25 #                                                                            #
26 #  THIS SOFTWARE IS PROVIDED BY INTEL CORPORATION ""AS IS"" AND ANY          #
27 #  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE         #
28 #  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR        #
29 #  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTEL CORPORATION OR            #
30 #  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,     #
31 #  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,       #
32 #  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR        #
33 #  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF    #
34 #  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING      #
35 #  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS        #
36 #  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.              #
37 #                                                                            #
38 ##############################################################################
39 # Developers and authors:                                                    #
40 # Shay Gueron (1, 2), and Vlad Krasnov (1)                                   #
41 # (1) Intel Architecture Group, Microprocessor and Chipset Development,      #
42 #     Israel Development Center, Haifa, Israel                               #
43 # (2) University of Haifa                                                    #
44 ##############################################################################
45 # Reference:                                                                 #
46 # [1] S. Gueron, "Efficient Software Implementations of Modular              #
47 #     Exponentiation", http://eprint.iacr.org/2011/239                       #
48 # [2] S. Gueron, V. Krasnov. "Speeding up Big-Numbers Squaring".             #
49 #     IEEE Proceedings of 9th International Conference on Information        #
50 #     Technology: New Generations (ITNG 2012), 821-823 (2012).               #
51 # [3] S. Gueron, Efficient Software Implementations of Modular Exponentiation#
52 #     Journal of Cryptographic Engineering 2:31-43 (2012).                   #
53 # [4] S. Gueron, V. Krasnov: "[PATCH] Efficient and side channel analysis    #
54 #     resistant 512-bit and 1024-bit modular exponentiation for optimizing   #
55 #     RSA1024 and RSA2048 on x86_64 platforms",                              #
56 #     http://rt.openssl.org/Ticket/Display.html?id=2582&user=guest&pass=guest#
57 ##############################################################################
58
59 # While original submission covers 512- and 1024-bit exponentiation,
60 # this module is limited to 512-bit version only (and as such
61 # accelerates RSA1024 sign). This is because improvement for longer
62 # keys is not high enough to justify the effort, highest measured
63 # was ~5% on Westmere. [This is relative to OpenSSL 1.0.2, upcoming
64 # for the moment of this writing!] Nor does this module implement
65 # "monolithic" complete exponentiation jumbo-subroutine, but adheres
66 # to more modular mixture of C and assembly. And it's optimized even
67 # for processors other than Intel Core family (see table below for
68 # improvement coefficients).
69 #                                               <appro@openssl.org>
70 #
71 # RSA1024 sign/sec      this/original   |this/rsax(*)   this/fips(*)
72 #                       ----------------+---------------------------
73 # Opteron               +13%            |+5%            +20%
74 # Bulldozer             -0%             |-1%            +10%
75 # P4                    +11%            |+7%            +8%
76 # Westmere              +5%             |+14%           +17%
77 # Sandy Bridge          +2%             |+12%           +29%
78 # Ivy Bridge            +1%             |+11%           +35%
79 # Haswell(**)           -0%             |+12%           +39%
80 # Atom                  +13%            |+11%           +4%
81 # VIA Nano              +70%            |+9%            +25%
82 #
83 # (*)   rsax engine and fips numbers are presented for reference
84 #       purposes;
85 # (**)  MULX was attempted, but found to give only marginal improvement;
86
87 $flavour = shift;
88 $output  = shift;
89 if ($flavour =~ /\./) { $output = $flavour; undef $flavour; }
90
91 $win64=0; $win64=1 if ($flavour =~ /[nm]asm|mingw64/ || $output =~ /\.asm$/);
92
93 $0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1;
94 ( $xlate="${dir}x86_64-xlate.pl" and -f $xlate ) or
95 ( $xlate="${dir}../../perlasm/x86_64-xlate.pl" and -f $xlate) or
96 die "can't locate x86_64-xlate.pl";
97
98 open OUT,"| \"$^X\" $xlate $flavour $output";
99 *STDOUT=*OUT;
100
101 if (`$ENV{CC} -Wa,-v -c -o /dev/null -x assembler /dev/null 2>&1`
102                 =~ /GNU assembler version ([2-9]\.[0-9]+)/) {
103         $addx = ($1>=2.23);
104 }
105
106 if (!$addx && $win64 && ($flavour =~ /nasm/ || $ENV{ASM} =~ /nasm/) &&
107             `nasm -v 2>&1` =~ /NASM version ([2-9]\.[0-9]+)/) {
108         $addx = ($1>=2.10);
109 }
110
111 if (!$addx && $win64 && ($flavour =~ /masm/ || $ENV{ASM} =~ /ml64/) &&
112             `ml64 2>&1` =~ /Version ([0-9]+)\./) {
113         $addx = ($1>=12);
114 }
115
116 if (!$addx && `$ENV{CC} -v 2>&1` =~ /(^clang version|based on LLVM) ([3-9])\.([0-9]+)/) {
117         my $ver = $2 + $3/100.0;        # 3.1->3.01, 3.10->3.10
118         $addx = ($ver>=3.03);
119 }
120
121 ($out, $inp, $mod) = ("%rdi", "%rsi", "%rbp");  # common internal API
122 {
123 my ($out,$inp,$mod,$n0,$times) = ("%rdi","%rsi","%rdx","%rcx","%r8d");
124
125 $code.=<<___;
126 .text
127
128 .extern OPENSSL_ia32cap_P
129
130 .globl  rsaz_512_sqr
131 .type   rsaz_512_sqr,\@function,5
132 .align  32
133 rsaz_512_sqr:                           # 25-29% faster than rsaz_512_mul
134         push    %rbx
135         push    %rbp
136         push    %r12
137         push    %r13
138         push    %r14
139         push    %r15
140
141         subq    \$128+24, %rsp
142 .Lsqr_body:
143         movq    $mod, %rbp              # common argument
144         movq    ($inp), %rdx
145         movq    8($inp), %rax
146         movq    $n0, 128(%rsp)
147 ___
148 $code.=<<___ if ($addx);
149         movl    \$0x80100,%r11d
150         andl    OPENSSL_ia32cap_P+8(%rip),%r11d
151         cmpl    \$0x80100,%r11d         # check for MULX and ADO/CX
152         je      .Loop_sqrx
153 ___
154 $code.=<<___;
155         jmp     .Loop_sqr
156
157 .align  32
158 .Loop_sqr:
159         movl    $times,128+8(%rsp)
160 #first iteration
161         movq    %rdx, %rbx
162         mulq    %rdx
163         movq    %rax, %r8
164         movq    16($inp), %rax
165         movq    %rdx, %r9
166
167         mulq    %rbx
168         addq    %rax, %r9
169         movq    24($inp), %rax
170         movq    %rdx, %r10
171         adcq    \$0, %r10
172
173         mulq    %rbx
174         addq    %rax, %r10
175         movq    32($inp), %rax
176         movq    %rdx, %r11
177         adcq    \$0, %r11
178
179         mulq    %rbx
180         addq    %rax, %r11
181         movq    40($inp), %rax
182         movq    %rdx, %r12
183         adcq    \$0, %r12
184
185         mulq    %rbx
186         addq    %rax, %r12
187         movq    48($inp), %rax
188         movq    %rdx, %r13
189         adcq    \$0, %r13
190
191         mulq    %rbx
192         addq    %rax, %r13
193         movq    56($inp), %rax
194         movq    %rdx, %r14
195         adcq    \$0, %r14
196
197         mulq    %rbx
198         addq    %rax, %r14
199         movq    %rbx, %rax
200         movq    %rdx, %r15
201         adcq    \$0, %r15
202
203         addq    %r8, %r8                #shlq   \$1, %r8
204         movq    %r9, %rcx
205         adcq    %r9, %r9                #shld   \$1, %r8, %r9
206
207         mulq    %rax
208         movq    %rax, (%rsp)
209         addq    %rdx, %r8
210         adcq    \$0, %r9
211
212         movq    %r8, 8(%rsp)
213         shrq    \$63, %rcx
214
215 #second iteration
216         movq    8($inp), %r8
217         movq    16($inp), %rax
218         mulq    %r8
219         addq    %rax, %r10
220         movq    24($inp), %rax
221         movq    %rdx, %rbx
222         adcq    \$0, %rbx
223
224         mulq    %r8
225         addq    %rax, %r11
226         movq    32($inp), %rax
227         adcq    \$0, %rdx
228         addq    %rbx, %r11
229         movq    %rdx, %rbx
230         adcq    \$0, %rbx
231
232         mulq    %r8
233         addq    %rax, %r12
234         movq    40($inp), %rax
235         adcq    \$0, %rdx
236         addq    %rbx, %r12
237         movq    %rdx, %rbx
238         adcq    \$0, %rbx
239
240         mulq    %r8
241         addq    %rax, %r13
242         movq    48($inp), %rax
243         adcq    \$0, %rdx
244         addq    %rbx, %r13
245         movq    %rdx, %rbx
246         adcq    \$0, %rbx
247
248         mulq    %r8
249         addq    %rax, %r14
250         movq    56($inp), %rax
251         adcq    \$0, %rdx
252         addq    %rbx, %r14
253         movq    %rdx, %rbx
254         adcq    \$0, %rbx
255
256         mulq    %r8
257         addq    %rax, %r15
258         movq    %r8, %rax
259         adcq    \$0, %rdx
260         addq    %rbx, %r15
261         movq    %rdx, %r8
262         movq    %r10, %rdx
263         adcq    \$0, %r8
264
265         add     %rdx, %rdx
266         lea     (%rcx,%r10,2), %r10     #shld   \$1, %rcx, %r10
267         movq    %r11, %rbx
268         adcq    %r11, %r11              #shld   \$1, %r10, %r11
269
270         mulq    %rax
271         addq    %rax, %r9
272         adcq    %rdx, %r10
273         adcq    \$0, %r11
274
275         movq    %r9, 16(%rsp)
276         movq    %r10, 24(%rsp)
277         shrq    \$63, %rbx
278         
279 #third iteration
280         movq    16($inp), %r9   
281         movq    24($inp), %rax
282         mulq    %r9
283         addq    %rax, %r12
284         movq    32($inp), %rax
285         movq    %rdx, %rcx
286         adcq    \$0, %rcx
287
288         mulq    %r9
289         addq    %rax, %r13
290         movq    40($inp), %rax
291         adcq    \$0, %rdx
292         addq    %rcx, %r13
293         movq    %rdx, %rcx
294         adcq    \$0, %rcx
295
296         mulq    %r9
297         addq    %rax, %r14
298         movq    48($inp), %rax
299         adcq    \$0, %rdx
300         addq    %rcx, %r14
301         movq    %rdx, %rcx
302         adcq    \$0, %rcx
303
304         mulq    %r9
305          movq   %r12, %r10
306          lea    (%rbx,%r12,2), %r12     #shld   \$1, %rbx, %r12
307         addq    %rax, %r15
308         movq    56($inp), %rax
309         adcq    \$0, %rdx
310         addq    %rcx, %r15
311         movq    %rdx, %rcx
312         adcq    \$0, %rcx
313
314         mulq    %r9
315          shrq   \$63, %r10
316         addq    %rax, %r8
317         movq    %r9, %rax
318         adcq    \$0, %rdx
319         addq    %rcx, %r8
320         movq    %rdx, %r9
321         adcq    \$0, %r9
322
323         movq    %r13, %rcx
324         leaq    (%r10,%r13,2), %r13     #shld   \$1, %r12, %r13
325
326         mulq    %rax
327         addq    %rax, %r11
328         adcq    %rdx, %r12
329         adcq    \$0, %r13
330
331         movq    %r11, 32(%rsp)
332         movq    %r12, 40(%rsp)
333         shrq    \$63, %rcx
334
335 #fourth iteration
336         movq    24($inp), %r10
337         movq    32($inp), %rax
338         mulq    %r10
339         addq    %rax, %r14
340         movq    40($inp), %rax
341         movq    %rdx, %rbx
342         adcq    \$0, %rbx
343
344         mulq    %r10
345         addq    %rax, %r15
346         movq    48($inp), %rax
347         adcq    \$0, %rdx
348         addq    %rbx, %r15
349         movq    %rdx, %rbx
350         adcq    \$0, %rbx
351
352         mulq    %r10
353          movq   %r14, %r12
354          leaq   (%rcx,%r14,2), %r14     #shld   \$1, %rcx, %r14
355         addq    %rax, %r8
356         movq    56($inp), %rax
357         adcq    \$0, %rdx
358         addq    %rbx, %r8
359         movq    %rdx, %rbx
360         adcq    \$0, %rbx
361
362         mulq    %r10
363          shrq   \$63, %r12
364         addq    %rax, %r9
365         movq    %r10, %rax
366         adcq    \$0, %rdx
367         addq    %rbx, %r9
368         movq    %rdx, %r10
369         adcq    \$0, %r10
370
371         movq    %r15, %rbx
372         leaq    (%r12,%r15,2),%r15      #shld   \$1, %r14, %r15
373
374         mulq    %rax
375         addq    %rax, %r13
376         adcq    %rdx, %r14
377         adcq    \$0, %r15
378
379         movq    %r13, 48(%rsp)
380         movq    %r14, 56(%rsp)
381         shrq    \$63, %rbx
382
383 #fifth iteration
384         movq    32($inp), %r11
385         movq    40($inp), %rax
386         mulq    %r11
387         addq    %rax, %r8
388         movq    48($inp), %rax
389         movq    %rdx, %rcx
390         adcq    \$0, %rcx
391
392         mulq    %r11
393         addq    %rax, %r9
394         movq    56($inp), %rax
395         adcq    \$0, %rdx
396          movq   %r8, %r12
397          leaq   (%rbx,%r8,2), %r8       #shld   \$1, %rbx, %r8
398         addq    %rcx, %r9
399         movq    %rdx, %rcx
400         adcq    \$0, %rcx
401
402         mulq    %r11
403          shrq   \$63, %r12
404         addq    %rax, %r10
405         movq    %r11, %rax
406         adcq    \$0, %rdx
407         addq    %rcx, %r10
408         movq    %rdx, %r11
409         adcq    \$0, %r11
410
411         movq    %r9, %rcx
412         leaq    (%r12,%r9,2), %r9       #shld   \$1, %r8, %r9
413
414         mulq    %rax
415         addq    %rax, %r15
416         adcq    %rdx, %r8
417         adcq    \$0, %r9
418
419         movq    %r15, 64(%rsp)
420         movq    %r8, 72(%rsp)
421         shrq    \$63, %rcx
422
423 #sixth iteration
424         movq    40($inp), %r12
425         movq    48($inp), %rax
426         mulq    %r12
427         addq    %rax, %r10
428         movq    56($inp), %rax
429         movq    %rdx, %rbx
430         adcq    \$0, %rbx
431
432         mulq    %r12
433         addq    %rax, %r11
434         movq    %r12, %rax
435          movq   %r10, %r15
436          leaq   (%rcx,%r10,2), %r10     #shld   \$1, %rcx, %r10
437         adcq    \$0, %rdx
438          shrq   \$63, %r15
439         addq    %rbx, %r11
440         movq    %rdx, %r12
441         adcq    \$0, %r12
442
443         movq    %r11, %rbx
444         leaq    (%r15,%r11,2), %r11     #shld   \$1, %r10, %r11
445
446         mulq    %rax
447         addq    %rax, %r9
448         adcq    %rdx, %r10
449         adcq    \$0, %r11
450
451         movq    %r9, 80(%rsp)
452         movq    %r10, 88(%rsp)
453
454 #seventh iteration
455         movq    48($inp), %r13
456         movq    56($inp), %rax
457         mulq    %r13
458         addq    %rax, %r12
459         movq    %r13, %rax
460         movq    %rdx, %r13
461         adcq    \$0, %r13
462
463         xorq    %r14, %r14
464         shlq    \$1, %rbx
465         adcq    %r12, %r12              #shld   \$1, %rbx, %r12
466         adcq    %r13, %r13              #shld   \$1, %r12, %r13
467         adcq    %r14, %r14              #shld   \$1, %r13, %r14
468
469         mulq    %rax
470         addq    %rax, %r11
471         adcq    %rdx, %r12
472         adcq    \$0, %r13
473
474         movq    %r11, 96(%rsp)
475         movq    %r12, 104(%rsp)
476
477 #eighth iteration
478         movq    56($inp), %rax
479         mulq    %rax
480         addq    %rax, %r13
481         adcq    \$0, %rdx
482
483         addq    %rdx, %r14
484
485         movq    %r13, 112(%rsp)
486         movq    %r14, 120(%rsp)
487
488         movq    (%rsp), %r8
489         movq    8(%rsp), %r9
490         movq    16(%rsp), %r10
491         movq    24(%rsp), %r11
492         movq    32(%rsp), %r12
493         movq    40(%rsp), %r13
494         movq    48(%rsp), %r14
495         movq    56(%rsp), %r15
496
497         call    __rsaz_512_reduce
498
499         addq    64(%rsp), %r8
500         adcq    72(%rsp), %r9
501         adcq    80(%rsp), %r10
502         adcq    88(%rsp), %r11
503         adcq    96(%rsp), %r12
504         adcq    104(%rsp), %r13
505         adcq    112(%rsp), %r14
506         adcq    120(%rsp), %r15
507         sbbq    %rcx, %rcx
508
509         call    __rsaz_512_subtract
510
511         movq    %r8, %rdx
512         movq    %r9, %rax
513         movl    128+8(%rsp), $times
514         movq    $out, $inp
515
516         decl    $times
517         jnz     .Loop_sqr
518 ___
519 if ($addx) {
520 $code.=<<___;
521         jmp     .Lsqr_tail
522
523 .align  32
524 .Loop_sqrx:
525         movl    $times,128+8(%rsp)
526         movq    $out, %xmm0             # off-load
527         movq    %rbp, %xmm1             # off-load
528 #first iteration        
529         mulx    %rax, %r8, %r9
530
531         mulx    16($inp), %rcx, %r10
532         xor     %rbp, %rbp              # cf=0, of=0
533
534         mulx    24($inp), %rax, %r11
535         adcx    %rcx, %r9
536
537         mulx    32($inp), %rcx, %r12
538         adcx    %rax, %r10
539
540         mulx    40($inp), %rax, %r13
541         adcx    %rcx, %r11
542
543         .byte   0xc4,0x62,0xf3,0xf6,0xb6,0x30,0x00,0x00,0x00    # mulx  48($inp), %rcx, %r14
544         adcx    %rax, %r12
545         adcx    %rcx, %r13
546
547         .byte   0xc4,0x62,0xfb,0xf6,0xbe,0x38,0x00,0x00,0x00    # mulx  56($inp), %rax, %r15
548         adcx    %rax, %r14
549         adcx    %rbp, %r15              # %rbp is 0
550
551         mov     %r9, %rcx
552         shld    \$1, %r8, %r9
553         shl     \$1, %r8
554
555         xor     %ebp, %ebp
556         mulx    %rdx, %rax, %rdx
557         adcx    %rdx, %r8
558          mov    8($inp), %rdx
559         adcx    %rbp, %r9
560
561         mov     %rax, (%rsp)
562         mov     %r8, 8(%rsp)
563
564 #second iteration       
565         mulx    16($inp), %rax, %rbx
566         adox    %rax, %r10
567         adcx    %rbx, %r11
568
569         .byte   0xc4,0x62,0xc3,0xf6,0x86,0x18,0x00,0x00,0x00    # mulx  24($inp), $out, %r8
570         adox    $out, %r11
571         adcx    %r8, %r12
572
573         mulx    32($inp), %rax, %rbx
574         adox    %rax, %r12
575         adcx    %rbx, %r13
576
577         mulx    40($inp), $out, %r8
578         adox    $out, %r13
579         adcx    %r8, %r14
580
581         .byte   0xc4,0xe2,0xfb,0xf6,0x9e,0x30,0x00,0x00,0x00    # mulx  48($inp), %rax, %rbx
582         adox    %rax, %r14
583         adcx    %rbx, %r15
584
585         .byte   0xc4,0x62,0xc3,0xf6,0x86,0x38,0x00,0x00,0x00    # mulx  56($inp), $out, %r8
586         adox    $out, %r15
587         adcx    %rbp, %r8
588         adox    %rbp, %r8
589
590         mov     %r11, %rbx
591         shld    \$1, %r10, %r11
592         shld    \$1, %rcx, %r10
593
594         xor     %ebp,%ebp
595         mulx    %rdx, %rax, %rcx
596          mov    16($inp), %rdx
597         adcx    %rax, %r9
598         adcx    %rcx, %r10
599         adcx    %rbp, %r11
600
601         mov     %r9, 16(%rsp)
602         .byte   0x4c,0x89,0x94,0x24,0x18,0x00,0x00,0x00         # mov   %r10, 24(%rsp)
603         
604 #third iteration        
605         .byte   0xc4,0x62,0xc3,0xf6,0x8e,0x18,0x00,0x00,0x00    # mulx  24($inp), $out, %r9
606         adox    $out, %r12
607         adcx    %r9, %r13
608
609         mulx    32($inp), %rax, %rcx
610         adox    %rax, %r13
611         adcx    %rcx, %r14
612
613         mulx    40($inp), $out, %r9
614         adox    $out, %r14
615         adcx    %r9, %r15
616
617         .byte   0xc4,0xe2,0xfb,0xf6,0x8e,0x30,0x00,0x00,0x00    # mulx  48($inp), %rax, %rcx
618         adox    %rax, %r15
619         adcx    %rcx, %r8
620
621         .byte   0xc4,0x62,0xc3,0xf6,0x8e,0x38,0x00,0x00,0x00    # mulx  56($inp), $out, %r9
622         adox    $out, %r8
623         adcx    %rbp, %r9
624         adox    %rbp, %r9
625
626         mov     %r13, %rcx
627         shld    \$1, %r12, %r13
628         shld    \$1, %rbx, %r12
629
630         xor     %ebp, %ebp
631         mulx    %rdx, %rax, %rdx
632         adcx    %rax, %r11
633         adcx    %rdx, %r12
634          mov    24($inp), %rdx
635         adcx    %rbp, %r13
636
637         mov     %r11, 32(%rsp)
638         .byte   0x4c,0x89,0xa4,0x24,0x28,0x00,0x00,0x00         # mov   %r12, 40(%rsp)
639         
640 #fourth iteration       
641         .byte   0xc4,0xe2,0xfb,0xf6,0x9e,0x20,0x00,0x00,0x00    # mulx  32($inp), %rax, %rbx
642         adox    %rax, %r14
643         adcx    %rbx, %r15
644
645         mulx    40($inp), $out, %r10
646         adox    $out, %r15
647         adcx    %r10, %r8
648
649         mulx    48($inp), %rax, %rbx
650         adox    %rax, %r8
651         adcx    %rbx, %r9
652
653         mulx    56($inp), $out, %r10
654         adox    $out, %r9
655         adcx    %rbp, %r10
656         adox    %rbp, %r10
657
658         .byte   0x66
659         mov     %r15, %rbx
660         shld    \$1, %r14, %r15
661         shld    \$1, %rcx, %r14
662
663         xor     %ebp, %ebp
664         mulx    %rdx, %rax, %rdx
665         adcx    %rax, %r13
666         adcx    %rdx, %r14
667          mov    32($inp), %rdx
668         adcx    %rbp, %r15
669
670         mov     %r13, 48(%rsp)
671         mov     %r14, 56(%rsp)
672         
673 #fifth iteration        
674         .byte   0xc4,0x62,0xc3,0xf6,0x9e,0x28,0x00,0x00,0x00    # mulx  40($inp), $out, %r11
675         adox    $out, %r8
676         adcx    %r11, %r9
677
678         mulx    48($inp), %rax, %rcx
679         adox    %rax, %r9
680         adcx    %rcx, %r10
681
682         mulx    56($inp), $out, %r11
683         adox    $out, %r10
684         adcx    %rbp, %r11
685         adox    %rbp, %r11
686
687         mov     %r9, %rcx
688         shld    \$1, %r8, %r9
689         shld    \$1, %rbx, %r8
690
691         xor     %ebp, %ebp
692         mulx    %rdx, %rax, %rdx
693         adcx    %rax, %r15
694         adcx    %rdx, %r8
695          mov    40($inp), %rdx
696         adcx    %rbp, %r9
697
698         mov     %r15, 64(%rsp)
699         mov     %r8, 72(%rsp)
700         
701 #sixth iteration        
702         .byte   0xc4,0xe2,0xfb,0xf6,0x9e,0x30,0x00,0x00,0x00    # mulx  48($inp), %rax, %rbx
703         adox    %rax, %r10
704         adcx    %rbx, %r11
705
706         .byte   0xc4,0x62,0xc3,0xf6,0xa6,0x38,0x00,0x00,0x00    # mulx  56($inp), $out, %r12
707         adox    $out, %r11
708         adcx    %rbp, %r12
709         adox    %rbp, %r12
710
711         mov     %r11, %rbx
712         shld    \$1, %r10, %r11
713         shld    \$1, %rcx, %r10
714
715         xor     %ebp, %ebp
716         mulx    %rdx, %rax, %rdx
717         adcx    %rax, %r9
718         adcx    %rdx, %r10
719          mov    48($inp), %rdx
720         adcx    %rbp, %r11
721
722         mov     %r9, 80(%rsp)
723         mov     %r10, 88(%rsp)
724
725 #seventh iteration
726         .byte   0xc4,0x62,0xfb,0xf6,0xae,0x38,0x00,0x00,0x00    # mulx  56($inp), %rax, %r13
727         adox    %rax, %r12
728         adox    %rbp, %r13
729
730         xor     %r14, %r14
731         shld    \$1, %r13, %r14
732         shld    \$1, %r12, %r13
733         shld    \$1, %rbx, %r12
734
735         xor     %ebp, %ebp
736         mulx    %rdx, %rax, %rdx
737         adcx    %rax, %r11
738         adcx    %rdx, %r12
739          mov    56($inp), %rdx
740         adcx    %rbp, %r13
741
742         .byte   0x4c,0x89,0x9c,0x24,0x60,0x00,0x00,0x00         # mov   %r11, 96(%rsp)
743         .byte   0x4c,0x89,0xa4,0x24,0x68,0x00,0x00,0x00         # mov   %r12, 104(%rsp)
744
745 #eighth iteration
746         mulx    %rdx, %rax, %rdx
747         adox    %rax, %r13
748         adox    %rbp, %rdx
749
750         .byte   0x66
751         add     %rdx, %r14
752
753         movq    %r13, 112(%rsp)
754         movq    %r14, 120(%rsp)
755         movq    %xmm0, $out
756         movq    %xmm1, %rbp
757
758         movq    128(%rsp), %rdx         # pull $n0
759         movq    (%rsp), %r8
760         movq    8(%rsp), %r9
761         movq    16(%rsp), %r10
762         movq    24(%rsp), %r11
763         movq    32(%rsp), %r12
764         movq    40(%rsp), %r13
765         movq    48(%rsp), %r14
766         movq    56(%rsp), %r15
767
768         call    __rsaz_512_reducex
769
770         addq    64(%rsp), %r8
771         adcq    72(%rsp), %r9
772         adcq    80(%rsp), %r10
773         adcq    88(%rsp), %r11
774         adcq    96(%rsp), %r12
775         adcq    104(%rsp), %r13
776         adcq    112(%rsp), %r14
777         adcq    120(%rsp), %r15
778         sbbq    %rcx, %rcx
779
780         call    __rsaz_512_subtract
781
782         movq    %r8, %rdx
783         movq    %r9, %rax
784         movl    128+8(%rsp), $times
785         movq    $out, $inp
786
787         decl    $times
788         jnz     .Loop_sqrx
789
790 .Lsqr_tail:
791 ___
792 }
793 $code.=<<___;
794
795         leaq    128+24+48(%rsp), %rax
796         movq    -48(%rax), %r15
797         movq    -40(%rax), %r14
798         movq    -32(%rax), %r13
799         movq    -24(%rax), %r12
800         movq    -16(%rax), %rbp
801         movq    -8(%rax), %rbx
802         leaq    (%rax), %rsp
803 .Lsqr_epilogue:
804         ret
805 .size   rsaz_512_sqr,.-rsaz_512_sqr
806 ___
807 }
808 {
809 my ($out,$ap,$bp,$mod,$n0) = ("%rdi","%rsi","%rdx","%rcx","%r8");
810 $code.=<<___;
811 .globl  rsaz_512_mul
812 .type   rsaz_512_mul,\@function,5
813 .align  32
814 rsaz_512_mul:
815         push    %rbx
816         push    %rbp
817         push    %r12
818         push    %r13
819         push    %r14
820         push    %r15
821
822         subq    \$128+24, %rsp
823 .Lmul_body:
824         movq    $out, %xmm0             # off-load arguments
825         movq    $mod, %xmm1
826         movq    $n0, 128(%rsp)
827 ___
828 $code.=<<___ if ($addx);
829         movl    \$0x80100,%r11d
830         andl    OPENSSL_ia32cap_P+8(%rip),%r11d
831         cmpl    \$0x80100,%r11d         # check for MULX and ADO/CX
832         je      .Lmulx
833 ___
834 $code.=<<___;
835         movq    ($bp), %rbx             # pass b[0]
836         movq    $bp, %rbp               # pass argument
837         call    __rsaz_512_mul
838
839         movq    %xmm0, $out
840         movq    %xmm1, %rbp
841
842         movq    (%rsp), %r8
843         movq    8(%rsp), %r9
844         movq    16(%rsp), %r10
845         movq    24(%rsp), %r11
846         movq    32(%rsp), %r12
847         movq    40(%rsp), %r13
848         movq    48(%rsp), %r14
849         movq    56(%rsp), %r15
850
851         call    __rsaz_512_reduce
852 ___
853 $code.=<<___ if ($addx);
854         jmp     .Lmul_tail
855
856 .align  32
857 .Lmulx:
858         movq    $bp, %rbp               # pass argument
859         movq    ($bp), %rdx             # pass b[0]
860         call    __rsaz_512_mulx
861
862         movq    %xmm0, $out
863         movq    %xmm1, %rbp
864
865         movq    128(%rsp), %rdx         # pull $n0
866         movq    (%rsp), %r8
867         movq    8(%rsp), %r9
868         movq    16(%rsp), %r10
869         movq    24(%rsp), %r11
870         movq    32(%rsp), %r12
871         movq    40(%rsp), %r13
872         movq    48(%rsp), %r14
873         movq    56(%rsp), %r15
874
875         call    __rsaz_512_reducex
876 .Lmul_tail:
877 ___
878 $code.=<<___;
879         addq    64(%rsp), %r8
880         adcq    72(%rsp), %r9
881         adcq    80(%rsp), %r10
882         adcq    88(%rsp), %r11
883         adcq    96(%rsp), %r12
884         adcq    104(%rsp), %r13
885         adcq    112(%rsp), %r14
886         adcq    120(%rsp), %r15
887         sbbq    %rcx, %rcx
888
889         call    __rsaz_512_subtract
890
891         leaq    128+24+48(%rsp), %rax
892         movq    -48(%rax), %r15
893         movq    -40(%rax), %r14
894         movq    -32(%rax), %r13
895         movq    -24(%rax), %r12
896         movq    -16(%rax), %rbp
897         movq    -8(%rax), %rbx
898         leaq    (%rax), %rsp
899 .Lmul_epilogue:
900         ret
901 .size   rsaz_512_mul,.-rsaz_512_mul
902 ___
903 }
904 {
905 my ($out,$ap,$bp,$mod,$n0,$pwr) = ("%rdi","%rsi","%rdx","%rcx","%r8","%r9d");
906 $code.=<<___;
907 .globl  rsaz_512_mul_gather4
908 .type   rsaz_512_mul_gather4,\@function,6
909 .align  32
910 rsaz_512_mul_gather4:
911         push    %rbx
912         push    %rbp
913         push    %r12
914         push    %r13
915         push    %r14
916         push    %r15
917
918         mov     $pwr, $pwr
919         subq    \$128+24, %rsp
920 .Lmul_gather4_body:
921 ___
922 $code.=<<___ if ($addx);
923         movl    \$0x80100,%r11d
924         andl    OPENSSL_ia32cap_P+8(%rip),%r11d
925         cmpl    \$0x80100,%r11d         # check for MULX and ADO/CX
926         je      .Lmulx_gather
927 ___
928 $code.=<<___;
929         movl    64($bp,$pwr,4), %eax
930         movq    $out, %xmm0             # off-load arguments
931         movl    ($bp,$pwr,4), %ebx
932         movq    $mod, %xmm1
933         movq    $n0, 128(%rsp)
934
935         shlq    \$32, %rax
936         or      %rax, %rbx
937         movq    ($ap), %rax
938          movq   8($ap), %rcx
939          leaq   128($bp,$pwr,4), %rbp
940         mulq    %rbx                    # 0 iteration
941         movq    %rax, (%rsp)
942         movq    %rcx, %rax
943         movq    %rdx, %r8
944
945         mulq    %rbx
946          movd   (%rbp), %xmm4
947         addq    %rax, %r8
948         movq    16($ap), %rax
949         movq    %rdx, %r9
950         adcq    \$0, %r9
951
952         mulq    %rbx
953          movd   64(%rbp), %xmm5
954         addq    %rax, %r9
955         movq    24($ap), %rax
956         movq    %rdx, %r10
957         adcq    \$0, %r10
958
959         mulq    %rbx
960          pslldq \$4, %xmm5
961         addq    %rax, %r10
962         movq    32($ap), %rax
963         movq    %rdx, %r11
964         adcq    \$0, %r11
965
966         mulq    %rbx
967          por    %xmm5, %xmm4
968         addq    %rax, %r11
969         movq    40($ap), %rax
970         movq    %rdx, %r12
971         adcq    \$0, %r12
972
973         mulq    %rbx
974         addq    %rax, %r12
975         movq    48($ap), %rax
976         movq    %rdx, %r13
977         adcq    \$0, %r13
978
979         mulq    %rbx
980          leaq   128(%rbp), %rbp
981         addq    %rax, %r13
982         movq    56($ap), %rax
983         movq    %rdx, %r14
984         adcq    \$0, %r14
985         
986         mulq    %rbx
987          movq   %xmm4, %rbx
988         addq    %rax, %r14
989          movq   ($ap), %rax
990         movq    %rdx, %r15
991         adcq    \$0, %r15
992
993         leaq    8(%rsp), %rdi
994         movl    \$7, %ecx
995         jmp     .Loop_mul_gather
996
997 .align  32
998 .Loop_mul_gather:
999         mulq    %rbx
1000         addq    %rax, %r8
1001         movq    8($ap), %rax
1002         movq    %r8, (%rdi)
1003         movq    %rdx, %r8
1004         adcq    \$0, %r8
1005
1006         mulq    %rbx
1007          movd   (%rbp), %xmm4
1008         addq    %rax, %r9
1009         movq    16($ap), %rax
1010         adcq    \$0, %rdx
1011         addq    %r9, %r8
1012         movq    %rdx, %r9
1013         adcq    \$0, %r9
1014
1015         mulq    %rbx
1016          movd   64(%rbp), %xmm5
1017         addq    %rax, %r10
1018         movq    24($ap), %rax
1019         adcq    \$0, %rdx
1020         addq    %r10, %r9
1021         movq    %rdx, %r10
1022         adcq    \$0, %r10
1023
1024         mulq    %rbx
1025          pslldq \$4, %xmm5
1026         addq    %rax, %r11
1027         movq    32($ap), %rax
1028         adcq    \$0, %rdx
1029         addq    %r11, %r10
1030         movq    %rdx, %r11
1031         adcq    \$0, %r11
1032
1033         mulq    %rbx
1034          por    %xmm5, %xmm4
1035         addq    %rax, %r12
1036         movq    40($ap), %rax
1037         adcq    \$0, %rdx
1038         addq    %r12, %r11
1039         movq    %rdx, %r12
1040         adcq    \$0, %r12
1041
1042         mulq    %rbx
1043         addq    %rax, %r13
1044         movq    48($ap), %rax
1045         adcq    \$0, %rdx
1046         addq    %r13, %r12
1047         movq    %rdx, %r13
1048         adcq    \$0, %r13
1049
1050         mulq    %rbx
1051         addq    %rax, %r14
1052         movq    56($ap), %rax
1053         adcq    \$0, %rdx
1054         addq    %r14, %r13
1055         movq    %rdx, %r14
1056         adcq    \$0, %r14
1057
1058         mulq    %rbx
1059          movq   %xmm4, %rbx
1060         addq    %rax, %r15
1061          movq   ($ap), %rax
1062         adcq    \$0, %rdx
1063         addq    %r15, %r14
1064         movq    %rdx, %r15      
1065         adcq    \$0, %r15
1066
1067         leaq    128(%rbp), %rbp
1068         leaq    8(%rdi), %rdi
1069
1070         decl    %ecx
1071         jnz     .Loop_mul_gather
1072
1073         movq    %r8, (%rdi)
1074         movq    %r9, 8(%rdi)
1075         movq    %r10, 16(%rdi)
1076         movq    %r11, 24(%rdi)
1077         movq    %r12, 32(%rdi)
1078         movq    %r13, 40(%rdi)
1079         movq    %r14, 48(%rdi)
1080         movq    %r15, 56(%rdi)
1081
1082         movq    %xmm0, $out
1083         movq    %xmm1, %rbp
1084
1085         movq    (%rsp), %r8
1086         movq    8(%rsp), %r9
1087         movq    16(%rsp), %r10
1088         movq    24(%rsp), %r11
1089         movq    32(%rsp), %r12
1090         movq    40(%rsp), %r13
1091         movq    48(%rsp), %r14
1092         movq    56(%rsp), %r15
1093
1094         call    __rsaz_512_reduce
1095 ___
1096 $code.=<<___ if ($addx);
1097         jmp     .Lmul_gather_tail
1098
1099 .align  32
1100 .Lmulx_gather:
1101         mov     64($bp,$pwr,4), %eax
1102         movq    $out, %xmm0             # off-load arguments
1103         lea     128($bp,$pwr,4), %rbp
1104         mov     ($bp,$pwr,4), %edx
1105         movq    $mod, %xmm1
1106         mov     $n0, 128(%rsp)
1107
1108         shl     \$32, %rax
1109         or      %rax, %rdx
1110         mulx    ($ap), %rbx, %r8        # 0 iteration
1111         mov     %rbx, (%rsp)
1112         xor     %edi, %edi              # cf=0, of=0
1113
1114         mulx    8($ap), %rax, %r9
1115          movd   (%rbp), %xmm4
1116
1117         mulx    16($ap), %rbx, %r10
1118          movd   64(%rbp), %xmm5
1119         adcx    %rax, %r8
1120
1121         mulx    24($ap), %rax, %r11
1122          pslldq \$4, %xmm5
1123         adcx    %rbx, %r9
1124
1125         mulx    32($ap), %rbx, %r12
1126          por    %xmm5, %xmm4
1127         adcx    %rax, %r10
1128
1129         mulx    40($ap), %rax, %r13
1130         adcx    %rbx, %r11
1131
1132         mulx    48($ap), %rbx, %r14
1133          lea    128(%rbp), %rbp
1134         adcx    %rax, %r12
1135         
1136         mulx    56($ap), %rax, %r15
1137          movq   %xmm4, %rdx
1138         adcx    %rbx, %r13
1139         adcx    %rax, %r14
1140         mov     %r8, %rbx
1141         adcx    %rdi, %r15              # %rdi is 0
1142
1143         mov     \$-7, %rcx
1144         jmp     .Loop_mulx_gather
1145
1146 .align  32
1147 .Loop_mulx_gather:
1148         mulx    ($ap), %rax, %r8
1149         adcx    %rax, %rbx
1150         adox    %r9, %r8
1151
1152         mulx    8($ap), %rax, %r9
1153         .byte   0x66,0x0f,0x6e,0xa5,0x00,0x00,0x00,0x00         # movd  (%rbp), %xmm4
1154         adcx    %rax, %r8
1155         adox    %r10, %r9
1156
1157         mulx    16($ap), %rax, %r10
1158          movd   64(%rbp), %xmm5
1159          lea    128(%rbp), %rbp
1160         adcx    %rax, %r9
1161         adox    %r11, %r10
1162
1163         .byte   0xc4,0x62,0xfb,0xf6,0x9e,0x18,0x00,0x00,0x00    # mulx  24($ap), %rax, %r11
1164          pslldq \$4, %xmm5
1165          por    %xmm5, %xmm4
1166         adcx    %rax, %r10
1167         adox    %r12, %r11
1168
1169         mulx    32($ap), %rax, %r12
1170         adcx    %rax, %r11
1171         adox    %r13, %r12
1172
1173         mulx    40($ap), %rax, %r13
1174         adcx    %rax, %r12
1175         adox    %r14, %r13
1176
1177         .byte   0xc4,0x62,0xfb,0xf6,0xb6,0x30,0x00,0x00,0x00    # mulx  48($ap), %rax, %r14
1178         adcx    %rax, %r13
1179         adox    %r15, %r14
1180
1181         mulx    56($ap), %rax, %r15
1182          movq   %xmm4, %rdx
1183          mov    %rbx, 64(%rsp,%rcx,8)
1184         adcx    %rax, %r14
1185         adox    %rdi, %r15
1186         mov     %r8, %rbx
1187         adcx    %rdi, %r15              # cf=0
1188
1189         inc     %rcx                    # of=0
1190         jnz     .Loop_mulx_gather
1191
1192         mov     %r8, 64(%rsp)
1193         mov     %r9, 64+8(%rsp)
1194         mov     %r10, 64+16(%rsp)
1195         mov     %r11, 64+24(%rsp)
1196         mov     %r12, 64+32(%rsp)
1197         mov     %r13, 64+40(%rsp)
1198         mov     %r14, 64+48(%rsp)
1199         mov     %r15, 64+56(%rsp)
1200
1201         movq    %xmm0, $out
1202         movq    %xmm1, %rbp
1203
1204         mov     128(%rsp), %rdx         # pull $n0
1205         mov     (%rsp), %r8
1206         mov     8(%rsp), %r9
1207         mov     16(%rsp), %r10
1208         mov     24(%rsp), %r11
1209         mov     32(%rsp), %r12
1210         mov     40(%rsp), %r13
1211         mov     48(%rsp), %r14
1212         mov     56(%rsp), %r15
1213
1214         call    __rsaz_512_reducex
1215
1216 .Lmul_gather_tail:
1217 ___
1218 $code.=<<___;
1219         addq    64(%rsp), %r8
1220         adcq    72(%rsp), %r9
1221         adcq    80(%rsp), %r10
1222         adcq    88(%rsp), %r11
1223         adcq    96(%rsp), %r12
1224         adcq    104(%rsp), %r13
1225         adcq    112(%rsp), %r14
1226         adcq    120(%rsp), %r15
1227         sbbq    %rcx, %rcx
1228
1229         call    __rsaz_512_subtract
1230
1231         leaq    128+24+48(%rsp), %rax
1232         movq    -48(%rax), %r15
1233         movq    -40(%rax), %r14
1234         movq    -32(%rax), %r13
1235         movq    -24(%rax), %r12
1236         movq    -16(%rax), %rbp
1237         movq    -8(%rax), %rbx
1238         leaq    (%rax), %rsp
1239 .Lmul_gather4_epilogue:
1240         ret
1241 .size   rsaz_512_mul_gather4,.-rsaz_512_mul_gather4
1242 ___
1243 }
1244 {
1245 my ($out,$ap,$mod,$n0,$tbl,$pwr) = ("%rdi","%rsi","%rdx","%rcx","%r8","%r9d");
1246 $code.=<<___;
1247 .globl  rsaz_512_mul_scatter4
1248 .type   rsaz_512_mul_scatter4,\@function,6
1249 .align  32
1250 rsaz_512_mul_scatter4:
1251         push    %rbx
1252         push    %rbp
1253         push    %r12
1254         push    %r13
1255         push    %r14
1256         push    %r15
1257
1258         mov     $pwr, $pwr
1259         subq    \$128+24, %rsp
1260 .Lmul_scatter4_body:
1261         leaq    ($tbl,$pwr,4), $tbl
1262         movq    $out, %xmm0             # off-load arguments
1263         movq    $mod, %xmm1
1264         movq    $tbl, %xmm2
1265         movq    $n0, 128(%rsp)
1266
1267         movq    $out, %rbp
1268 ___
1269 $code.=<<___ if ($addx);
1270         movl    \$0x80100,%r11d
1271         andl    OPENSSL_ia32cap_P+8(%rip),%r11d
1272         cmpl    \$0x80100,%r11d         # check for MULX and ADO/CX
1273         je      .Lmulx_scatter
1274 ___
1275 $code.=<<___;
1276         movq    ($out),%rbx             # pass b[0]
1277         call    __rsaz_512_mul
1278
1279         movq    %xmm0, $out
1280         movq    %xmm1, %rbp
1281
1282         movq    (%rsp), %r8
1283         movq    8(%rsp), %r9
1284         movq    16(%rsp), %r10
1285         movq    24(%rsp), %r11
1286         movq    32(%rsp), %r12
1287         movq    40(%rsp), %r13
1288         movq    48(%rsp), %r14
1289         movq    56(%rsp), %r15
1290
1291         call    __rsaz_512_reduce
1292 ___
1293 $code.=<<___ if ($addx);
1294         jmp     .Lmul_scatter_tail
1295         
1296 .align  32
1297 .Lmulx_scatter:
1298         movq    ($out), %rdx            # pass b[0]
1299         call    __rsaz_512_mulx
1300
1301         movq    %xmm0, $out
1302         movq    %xmm1, %rbp
1303
1304         movq    128(%rsp), %rdx         # pull $n0
1305         movq    (%rsp), %r8
1306         movq    8(%rsp), %r9
1307         movq    16(%rsp), %r10
1308         movq    24(%rsp), %r11
1309         movq    32(%rsp), %r12
1310         movq    40(%rsp), %r13
1311         movq    48(%rsp), %r14
1312         movq    56(%rsp), %r15
1313
1314         call    __rsaz_512_reducex
1315
1316 .Lmul_scatter_tail:
1317 ___
1318 $code.=<<___;
1319         addq    64(%rsp), %r8
1320         adcq    72(%rsp), %r9
1321         adcq    80(%rsp), %r10
1322         adcq    88(%rsp), %r11
1323         adcq    96(%rsp), %r12
1324         adcq    104(%rsp), %r13
1325         adcq    112(%rsp), %r14
1326         adcq    120(%rsp), %r15
1327         movq    %xmm2, $inp
1328         sbbq    %rcx, %rcx
1329
1330         call    __rsaz_512_subtract
1331
1332         movl    %r8d, 64*0($inp)        # scatter
1333         shrq    \$32, %r8
1334         movl    %r9d, 64*2($inp)
1335         shrq    \$32, %r9
1336         movl    %r10d, 64*4($inp)
1337         shrq    \$32, %r10
1338         movl    %r11d, 64*6($inp)
1339         shrq    \$32, %r11
1340         movl    %r12d, 64*8($inp)
1341         shrq    \$32, %r12
1342         movl    %r13d, 64*10($inp)
1343         shrq    \$32, %r13
1344         movl    %r14d, 64*12($inp)
1345         shrq    \$32, %r14
1346         movl    %r15d, 64*14($inp)
1347         shrq    \$32, %r15
1348         movl    %r8d, 64*1($inp)
1349         movl    %r9d, 64*3($inp)
1350         movl    %r10d, 64*5($inp)
1351         movl    %r11d, 64*7($inp)
1352         movl    %r12d, 64*9($inp)
1353         movl    %r13d, 64*11($inp)
1354         movl    %r14d, 64*13($inp)
1355         movl    %r15d, 64*15($inp)
1356
1357         leaq    128+24+48(%rsp), %rax
1358         movq    -48(%rax), %r15
1359         movq    -40(%rax), %r14
1360         movq    -32(%rax), %r13
1361         movq    -24(%rax), %r12
1362         movq    -16(%rax), %rbp
1363         movq    -8(%rax), %rbx
1364         leaq    (%rax), %rsp
1365 .Lmul_scatter4_epilogue:
1366         ret
1367 .size   rsaz_512_mul_scatter4,.-rsaz_512_mul_scatter4
1368 ___
1369 }
1370 {
1371 my ($out,$inp,$mod,$n0) = ("%rdi","%rsi","%rdx","%rcx");
1372 $code.=<<___;
1373 .globl  rsaz_512_mul_by_one
1374 .type   rsaz_512_mul_by_one,\@function,4
1375 .align  32
1376 rsaz_512_mul_by_one:
1377         push    %rbx
1378         push    %rbp
1379         push    %r12
1380         push    %r13
1381         push    %r14
1382         push    %r15
1383
1384         subq    \$128+24, %rsp
1385 .Lmul_by_one_body:
1386 ___
1387 $code.=<<___ if ($addx);
1388         movl    OPENSSL_ia32cap_P+8(%rip),%eax
1389 ___
1390 $code.=<<___;
1391         movq    $mod, %rbp      # reassign argument
1392         movq    $n0, 128(%rsp)
1393
1394         movq    ($inp), %r8
1395         pxor    %xmm0, %xmm0
1396         movq    8($inp), %r9
1397         movq    16($inp), %r10
1398         movq    24($inp), %r11
1399         movq    32($inp), %r12
1400         movq    40($inp), %r13
1401         movq    48($inp), %r14
1402         movq    56($inp), %r15
1403
1404         movdqa  %xmm0, (%rsp)
1405         movdqa  %xmm0, 16(%rsp)
1406         movdqa  %xmm0, 32(%rsp)
1407         movdqa  %xmm0, 48(%rsp)
1408         movdqa  %xmm0, 64(%rsp)
1409         movdqa  %xmm0, 80(%rsp)
1410         movdqa  %xmm0, 96(%rsp)
1411 ___
1412 $code.=<<___ if ($addx);
1413         andl    \$0x80100,%eax
1414         cmpl    \$0x80100,%eax          # check for MULX and ADO/CX
1415         je      .Lby_one_callx
1416 ___
1417 $code.=<<___;
1418         call    __rsaz_512_reduce
1419 ___
1420 $code.=<<___ if ($addx);
1421         jmp     .Lby_one_tail
1422 .align  32
1423 .Lby_one_callx:
1424         movq    128(%rsp), %rdx         # pull $n0
1425         call    __rsaz_512_reducex
1426 .Lby_one_tail:
1427 ___
1428 $code.=<<___;
1429         movq    %r8, ($out)
1430         movq    %r9, 8($out)
1431         movq    %r10, 16($out)
1432         movq    %r11, 24($out)
1433         movq    %r12, 32($out)
1434         movq    %r13, 40($out)
1435         movq    %r14, 48($out)
1436         movq    %r15, 56($out)
1437
1438         leaq    128+24+48(%rsp), %rax
1439         movq    -48(%rax), %r15
1440         movq    -40(%rax), %r14
1441         movq    -32(%rax), %r13
1442         movq    -24(%rax), %r12
1443         movq    -16(%rax), %rbp
1444         movq    -8(%rax), %rbx
1445         leaq    (%rax), %rsp
1446 .Lmul_by_one_epilogue:
1447         ret
1448 .size   rsaz_512_mul_by_one,.-rsaz_512_mul_by_one
1449 ___
1450 }
1451 {       # __rsaz_512_reduce
1452         #
1453         # input:        %r8-%r15, %rbp - mod, 128(%rsp) - n0
1454         # output:       %r8-%r15
1455         # clobbers:     everything except %rbp and %rdi
1456 $code.=<<___;
1457 .type   __rsaz_512_reduce,\@abi-omnipotent
1458 .align  32
1459 __rsaz_512_reduce:
1460         movq    %r8, %rbx
1461         imulq   128+8(%rsp), %rbx
1462         movq    0(%rbp), %rax
1463         movl    \$8, %ecx
1464         jmp     .Lreduction_loop
1465
1466 .align  32
1467 .Lreduction_loop:
1468         mulq    %rbx
1469         movq    8(%rbp), %rax
1470         negq    %r8
1471         movq    %rdx, %r8
1472         adcq    \$0, %r8
1473
1474         mulq    %rbx
1475         addq    %rax, %r9
1476         movq    16(%rbp), %rax
1477         adcq    \$0, %rdx
1478         addq    %r9, %r8
1479         movq    %rdx, %r9
1480         adcq    \$0, %r9
1481
1482         mulq    %rbx
1483         addq    %rax, %r10
1484         movq    24(%rbp), %rax
1485         adcq    \$0, %rdx
1486         addq    %r10, %r9
1487         movq    %rdx, %r10
1488         adcq    \$0, %r10
1489
1490         mulq    %rbx
1491         addq    %rax, %r11
1492         movq    32(%rbp), %rax
1493         adcq    \$0, %rdx
1494         addq    %r11, %r10
1495          movq   128+8(%rsp), %rsi
1496         #movq   %rdx, %r11
1497         #adcq   \$0, %r11
1498         adcq    \$0, %rdx
1499         movq    %rdx, %r11
1500
1501         mulq    %rbx
1502         addq    %rax, %r12
1503         movq    40(%rbp), %rax
1504         adcq    \$0, %rdx
1505          imulq  %r8, %rsi
1506         addq    %r12, %r11
1507         movq    %rdx, %r12
1508         adcq    \$0, %r12
1509
1510         mulq    %rbx
1511         addq    %rax, %r13
1512         movq    48(%rbp), %rax
1513         adcq    \$0, %rdx
1514         addq    %r13, %r12
1515         movq    %rdx, %r13
1516         adcq    \$0, %r13
1517
1518         mulq    %rbx
1519         addq    %rax, %r14
1520         movq    56(%rbp), %rax
1521         adcq    \$0, %rdx
1522         addq    %r14, %r13
1523         movq    %rdx, %r14
1524         adcq    \$0, %r14
1525
1526         mulq    %rbx
1527          movq   %rsi, %rbx
1528         addq    %rax, %r15
1529          movq   0(%rbp), %rax
1530         adcq    \$0, %rdx
1531         addq    %r15, %r14
1532         movq    %rdx, %r15
1533         adcq    \$0, %r15
1534
1535         decl    %ecx
1536         jne     .Lreduction_loop
1537
1538         ret
1539 .size   __rsaz_512_reduce,.-__rsaz_512_reduce
1540 ___
1541 }
1542 if ($addx) {
1543         # __rsaz_512_reducex
1544         #
1545         # input:        %r8-%r15, %rbp - mod, 128(%rsp) - n0
1546         # output:       %r8-%r15
1547         # clobbers:     everything except %rbp and %rdi
1548 $code.=<<___;
1549 .type   __rsaz_512_reducex,\@abi-omnipotent
1550 .align  32
1551 __rsaz_512_reducex:
1552         #movq   128+8(%rsp), %rdx               # pull $n0
1553         imulq   %r8, %rdx
1554         xorq    %rsi, %rsi                      # cf=0,of=0
1555         movl    \$8, %ecx
1556         jmp     .Lreduction_loopx
1557
1558 .align  32
1559 .Lreduction_loopx:
1560         mov     %r8, %rbx
1561         mulx    0(%rbp), %rax, %r8
1562         adcx    %rbx, %rax
1563         adox    %r9, %r8
1564
1565         mulx    8(%rbp), %rax, %r9
1566         adcx    %rax, %r8
1567         adox    %r10, %r9
1568
1569         mulx    16(%rbp), %rbx, %r10
1570         adcx    %rbx, %r9
1571         adox    %r11, %r10
1572
1573         mulx    24(%rbp), %rbx, %r11
1574         adcx    %rbx, %r10
1575         adox    %r12, %r11
1576
1577         .byte   0xc4,0x62,0xe3,0xf6,0xa5,0x20,0x00,0x00,0x00    # mulx  32(%rbp), %rbx, %r12
1578          mov    %rdx, %rax
1579          mov    %r8, %rdx
1580         adcx    %rbx, %r11
1581         adox    %r13, %r12
1582
1583          mulx   128+8(%rsp), %rbx, %rdx
1584          mov    %rax, %rdx
1585
1586         mulx    40(%rbp), %rax, %r13
1587         adcx    %rax, %r12
1588         adox    %r14, %r13
1589
1590         .byte   0xc4,0x62,0xfb,0xf6,0xb5,0x30,0x00,0x00,0x00    # mulx  48(%rbp), %rax, %r14
1591         adcx    %rax, %r13
1592         adox    %r15, %r14
1593
1594         mulx    56(%rbp), %rax, %r15
1595          mov    %rbx, %rdx
1596         adcx    %rax, %r14
1597         adox    %rsi, %r15                      # %rsi is 0
1598         adcx    %rsi, %r15                      # cf=0
1599
1600         decl    %ecx                            # of=0
1601         jne     .Lreduction_loopx
1602
1603         ret
1604 .size   __rsaz_512_reducex,.-__rsaz_512_reducex
1605 ___
1606 }
1607 {       # __rsaz_512_subtract
1608         # input: %r8-%r15, %rdi - $out, %rbp - $mod, %rcx - mask
1609         # output:
1610         # clobbers: everything but %rdi, %rsi and %rbp
1611 $code.=<<___;
1612 .type   __rsaz_512_subtract,\@abi-omnipotent
1613 .align  32
1614 __rsaz_512_subtract:
1615         movq    %r8, ($out)
1616         movq    %r9, 8($out)
1617         movq    %r10, 16($out)
1618         movq    %r11, 24($out)
1619         movq    %r12, 32($out)
1620         movq    %r13, 40($out)
1621         movq    %r14, 48($out)
1622         movq    %r15, 56($out)
1623
1624         movq    0($mod), %r8
1625         movq    8($mod), %r9
1626         negq    %r8
1627         notq    %r9
1628         andq    %rcx, %r8
1629         movq    16($mod), %r10
1630         andq    %rcx, %r9
1631         notq    %r10
1632         movq    24($mod), %r11
1633         andq    %rcx, %r10
1634         notq    %r11
1635         movq    32($mod), %r12
1636         andq    %rcx, %r11
1637         notq    %r12
1638         movq    40($mod), %r13
1639         andq    %rcx, %r12
1640         notq    %r13
1641         movq    48($mod), %r14
1642         andq    %rcx, %r13
1643         notq    %r14
1644         movq    56($mod), %r15
1645         andq    %rcx, %r14
1646         notq    %r15
1647         andq    %rcx, %r15
1648
1649         addq    ($out), %r8
1650         adcq    8($out), %r9
1651         adcq    16($out), %r10
1652         adcq    24($out), %r11
1653         adcq    32($out), %r12
1654         adcq    40($out), %r13
1655         adcq    48($out), %r14
1656         adcq    56($out), %r15
1657
1658         movq    %r8, ($out)
1659         movq    %r9, 8($out)
1660         movq    %r10, 16($out)
1661         movq    %r11, 24($out)
1662         movq    %r12, 32($out)
1663         movq    %r13, 40($out)
1664         movq    %r14, 48($out)
1665         movq    %r15, 56($out)
1666
1667         ret
1668 .size   __rsaz_512_subtract,.-__rsaz_512_subtract
1669 ___
1670 }
1671 {       # __rsaz_512_mul
1672         #
1673         # input: %rsi - ap, %rbp - bp
1674         # ouput:
1675         # clobbers: everything
1676 my ($ap,$bp) = ("%rsi","%rbp");
1677 $code.=<<___;
1678 .type   __rsaz_512_mul,\@abi-omnipotent
1679 .align  32
1680 __rsaz_512_mul:
1681         leaq    8(%rsp), %rdi
1682
1683         movq    ($ap), %rax
1684         mulq    %rbx
1685         movq    %rax, (%rdi)
1686         movq    8($ap), %rax
1687         movq    %rdx, %r8
1688
1689         mulq    %rbx
1690         addq    %rax, %r8
1691         movq    16($ap), %rax
1692         movq    %rdx, %r9
1693         adcq    \$0, %r9
1694
1695         mulq    %rbx
1696         addq    %rax, %r9
1697         movq    24($ap), %rax
1698         movq    %rdx, %r10
1699         adcq    \$0, %r10
1700
1701         mulq    %rbx
1702         addq    %rax, %r10
1703         movq    32($ap), %rax
1704         movq    %rdx, %r11
1705         adcq    \$0, %r11
1706
1707         mulq    %rbx
1708         addq    %rax, %r11
1709         movq    40($ap), %rax
1710         movq    %rdx, %r12
1711         adcq    \$0, %r12
1712
1713         mulq    %rbx
1714         addq    %rax, %r12
1715         movq    48($ap), %rax
1716         movq    %rdx, %r13
1717         adcq    \$0, %r13
1718
1719         mulq    %rbx
1720         addq    %rax, %r13
1721         movq    56($ap), %rax
1722         movq    %rdx, %r14
1723         adcq    \$0, %r14
1724         
1725         mulq    %rbx
1726         addq    %rax, %r14
1727          movq   ($ap), %rax
1728         movq    %rdx, %r15
1729         adcq    \$0, %r15
1730
1731         leaq    8($bp), $bp
1732         leaq    8(%rdi), %rdi
1733
1734         movl    \$7, %ecx
1735         jmp     .Loop_mul
1736
1737 .align  32
1738 .Loop_mul:
1739         movq    ($bp), %rbx
1740         mulq    %rbx
1741         addq    %rax, %r8
1742         movq    8($ap), %rax
1743         movq    %r8, (%rdi)
1744         movq    %rdx, %r8
1745         adcq    \$0, %r8
1746
1747         mulq    %rbx
1748         addq    %rax, %r9
1749         movq    16($ap), %rax
1750         adcq    \$0, %rdx
1751         addq    %r9, %r8
1752         movq    %rdx, %r9
1753         adcq    \$0, %r9
1754
1755         mulq    %rbx
1756         addq    %rax, %r10
1757         movq    24($ap), %rax
1758         adcq    \$0, %rdx
1759         addq    %r10, %r9
1760         movq    %rdx, %r10
1761         adcq    \$0, %r10
1762
1763         mulq    %rbx
1764         addq    %rax, %r11
1765         movq    32($ap), %rax
1766         adcq    \$0, %rdx
1767         addq    %r11, %r10
1768         movq    %rdx, %r11
1769         adcq    \$0, %r11
1770
1771         mulq    %rbx
1772         addq    %rax, %r12
1773         movq    40($ap), %rax
1774         adcq    \$0, %rdx
1775         addq    %r12, %r11
1776         movq    %rdx, %r12
1777         adcq    \$0, %r12
1778
1779         mulq    %rbx
1780         addq    %rax, %r13
1781         movq    48($ap), %rax
1782         adcq    \$0, %rdx
1783         addq    %r13, %r12
1784         movq    %rdx, %r13
1785         adcq    \$0, %r13
1786
1787         mulq    %rbx
1788         addq    %rax, %r14
1789         movq    56($ap), %rax
1790         adcq    \$0, %rdx
1791         addq    %r14, %r13
1792         movq    %rdx, %r14
1793          leaq   8($bp), $bp
1794         adcq    \$0, %r14
1795
1796         mulq    %rbx
1797         addq    %rax, %r15
1798          movq   ($ap), %rax
1799         adcq    \$0, %rdx
1800         addq    %r15, %r14
1801         movq    %rdx, %r15      
1802         adcq    \$0, %r15
1803
1804         leaq    8(%rdi), %rdi
1805
1806         decl    %ecx
1807         jnz     .Loop_mul
1808
1809         movq    %r8, (%rdi)
1810         movq    %r9, 8(%rdi)
1811         movq    %r10, 16(%rdi)
1812         movq    %r11, 24(%rdi)
1813         movq    %r12, 32(%rdi)
1814         movq    %r13, 40(%rdi)
1815         movq    %r14, 48(%rdi)
1816         movq    %r15, 56(%rdi)
1817
1818         ret
1819 .size   __rsaz_512_mul,.-__rsaz_512_mul
1820 ___
1821 }
1822 if ($addx) {
1823         # __rsaz_512_mulx
1824         #
1825         # input: %rsi - ap, %rbp - bp
1826         # ouput:
1827         # clobbers: everything
1828 my ($ap,$bp,$zero) = ("%rsi","%rbp","%rdi");
1829 $code.=<<___;
1830 .type   __rsaz_512_mulx,\@abi-omnipotent
1831 .align  32
1832 __rsaz_512_mulx:
1833         mulx    ($ap), %rbx, %r8        # initial %rdx preloaded by caller
1834         mov     \$-6, %rcx
1835
1836         mulx    8($ap), %rax, %r9
1837         movq    %rbx, 8(%rsp)
1838
1839         mulx    16($ap), %rbx, %r10
1840         adc     %rax, %r8
1841
1842         mulx    24($ap), %rax, %r11
1843         adc     %rbx, %r9
1844
1845         mulx    32($ap), %rbx, %r12
1846         adc     %rax, %r10
1847
1848         mulx    40($ap), %rax, %r13
1849         adc     %rbx, %r11
1850
1851         mulx    48($ap), %rbx, %r14
1852         adc     %rax, %r12
1853
1854         mulx    56($ap), %rax, %r15
1855          mov    8($bp), %rdx
1856         adc     %rbx, %r13
1857         adc     %rax, %r14
1858         adc     \$0, %r15
1859
1860         xor     $zero, $zero            # cf=0,of=0
1861         jmp     .Loop_mulx
1862
1863 .align  32
1864 .Loop_mulx:
1865         movq    %r8, %rbx
1866         mulx    ($ap), %rax, %r8
1867         adcx    %rax, %rbx
1868         adox    %r9, %r8
1869
1870         mulx    8($ap), %rax, %r9
1871         adcx    %rax, %r8
1872         adox    %r10, %r9
1873
1874         mulx    16($ap), %rax, %r10
1875         adcx    %rax, %r9
1876         adox    %r11, %r10
1877
1878         mulx    24($ap), %rax, %r11
1879         adcx    %rax, %r10
1880         adox    %r12, %r11
1881
1882         .byte   0x3e,0xc4,0x62,0xfb,0xf6,0xa6,0x20,0x00,0x00,0x00       # mulx  32($ap), %rax, %r12
1883         adcx    %rax, %r11
1884         adox    %r13, %r12
1885
1886         mulx    40($ap), %rax, %r13
1887         adcx    %rax, %r12
1888         adox    %r14, %r13
1889
1890         mulx    48($ap), %rax, %r14
1891         adcx    %rax, %r13
1892         adox    %r15, %r14
1893
1894         mulx    56($ap), %rax, %r15
1895          movq   64($bp,%rcx,8), %rdx
1896          movq   %rbx, 8+64-8(%rsp,%rcx,8)
1897         adcx    %rax, %r14
1898         adox    $zero, %r15
1899         adcx    $zero, %r15             # cf=0
1900
1901         inc     %rcx                    # of=0
1902         jnz     .Loop_mulx
1903
1904         movq    %r8, %rbx
1905         mulx    ($ap), %rax, %r8
1906         adcx    %rax, %rbx
1907         adox    %r9, %r8
1908
1909         .byte   0xc4,0x62,0xfb,0xf6,0x8e,0x08,0x00,0x00,0x00    # mulx  8($ap), %rax, %r9
1910         adcx    %rax, %r8
1911         adox    %r10, %r9
1912
1913         .byte   0xc4,0x62,0xfb,0xf6,0x96,0x10,0x00,0x00,0x00    # mulx  16($ap), %rax, %r10
1914         adcx    %rax, %r9
1915         adox    %r11, %r10
1916
1917         mulx    24($ap), %rax, %r11
1918         adcx    %rax, %r10
1919         adox    %r12, %r11
1920
1921         mulx    32($ap), %rax, %r12
1922         adcx    %rax, %r11
1923         adox    %r13, %r12
1924
1925         mulx    40($ap), %rax, %r13
1926         adcx    %rax, %r12
1927         adox    %r14, %r13
1928
1929         .byte   0xc4,0x62,0xfb,0xf6,0xb6,0x30,0x00,0x00,0x00    # mulx  48($ap), %rax, %r14
1930         adcx    %rax, %r13
1931         adox    %r15, %r14
1932
1933         .byte   0xc4,0x62,0xfb,0xf6,0xbe,0x38,0x00,0x00,0x00    # mulx  56($ap), %rax, %r15
1934         adcx    %rax, %r14
1935         adox    $zero, %r15
1936         adcx    $zero, %r15
1937
1938         mov     %rbx, 8+64-8(%rsp)
1939         mov     %r8, 8+64(%rsp)
1940         mov     %r9, 8+64+8(%rsp)
1941         mov     %r10, 8+64+16(%rsp)
1942         mov     %r11, 8+64+24(%rsp)
1943         mov     %r12, 8+64+32(%rsp)
1944         mov     %r13, 8+64+40(%rsp)
1945         mov     %r14, 8+64+48(%rsp)
1946         mov     %r15, 8+64+56(%rsp)
1947
1948         ret
1949 .size   __rsaz_512_mulx,.-__rsaz_512_mulx
1950 ___
1951 }
1952 {
1953 my ($out,$inp,$power)= $win64 ? ("%rcx","%rdx","%r8d") : ("%rdi","%rsi","%edx");
1954 $code.=<<___;
1955 .globl  rsaz_512_scatter4
1956 .type   rsaz_512_scatter4,\@abi-omnipotent
1957 .align  16
1958 rsaz_512_scatter4:
1959         leaq    ($out,$power,4), $out
1960         movl    \$8, %r9d
1961         jmp     .Loop_scatter
1962 .align  16
1963 .Loop_scatter:
1964         movq    ($inp), %rax
1965         leaq    8($inp), $inp
1966         movl    %eax, ($out)
1967         shrq    \$32, %rax
1968         movl    %eax, 64($out)
1969         leaq    128($out), $out
1970         decl    %r9d
1971         jnz     .Loop_scatter
1972         ret
1973 .size   rsaz_512_scatter4,.-rsaz_512_scatter4
1974
1975 .globl  rsaz_512_gather4
1976 .type   rsaz_512_gather4,\@abi-omnipotent
1977 .align  16
1978 rsaz_512_gather4:
1979         leaq    ($inp,$power,4), $inp
1980         movl    \$8, %r9d
1981         jmp     .Loop_gather
1982 .align  16
1983 .Loop_gather:
1984         movl    ($inp), %eax
1985         movl    64($inp), %r8d
1986         leaq    128($inp), $inp
1987         shlq    \$32, %r8
1988         or      %r8, %rax
1989         movq    %rax, ($out)
1990         leaq    8($out), $out
1991         decl    %r9d
1992         jnz     .Loop_gather
1993         ret
1994 .size   rsaz_512_gather4,.-rsaz_512_gather4
1995 ___
1996 }
1997
1998 # EXCEPTION_DISPOSITION handler (EXCEPTION_RECORD *rec,ULONG64 frame,
1999 #               CONTEXT *context,DISPATCHER_CONTEXT *disp)
2000 if ($win64) {
2001 $rec="%rcx";
2002 $frame="%rdx";
2003 $context="%r8";
2004 $disp="%r9";
2005
2006 $code.=<<___;
2007 .extern __imp_RtlVirtualUnwind
2008 .type   se_handler,\@abi-omnipotent
2009 .align  16
2010 se_handler:
2011         push    %rsi
2012         push    %rdi
2013         push    %rbx
2014         push    %rbp
2015         push    %r12
2016         push    %r13
2017         push    %r14
2018         push    %r15
2019         pushfq
2020         sub     \$64,%rsp
2021
2022         mov     120($context),%rax      # pull context->Rax
2023         mov     248($context),%rbx      # pull context->Rip
2024
2025         mov     8($disp),%rsi           # disp->ImageBase
2026         mov     56($disp),%r11          # disp->HandlerData
2027
2028         mov     0(%r11),%r10d           # HandlerData[0]
2029         lea     (%rsi,%r10),%r10        # end of prologue label
2030         cmp     %r10,%rbx               # context->Rip<end of prologue label
2031         jb      .Lcommon_seh_tail
2032
2033         mov     152($context),%rax      # pull context->Rsp
2034
2035         mov     4(%r11),%r10d           # HandlerData[1]
2036         lea     (%rsi,%r10),%r10        # epilogue label
2037         cmp     %r10,%rbx               # context->Rip>=epilogue label
2038         jae     .Lcommon_seh_tail
2039
2040         lea     128+24+48(%rax),%rax
2041
2042         mov     -8(%rax),%rbx
2043         mov     -16(%rax),%rbp
2044         mov     -24(%rax),%r12
2045         mov     -32(%rax),%r13
2046         mov     -40(%rax),%r14
2047         mov     -48(%rax),%r15
2048         mov     %rbx,144($context)      # restore context->Rbx
2049         mov     %rbp,160($context)      # restore context->Rbp
2050         mov     %r12,216($context)      # restore context->R12
2051         mov     %r13,224($context)      # restore context->R13
2052         mov     %r14,232($context)      # restore context->R14
2053         mov     %r15,240($context)      # restore context->R15
2054
2055 .Lcommon_seh_tail:
2056         mov     8(%rax),%rdi
2057         mov     16(%rax),%rsi
2058         mov     %rax,152($context)      # restore context->Rsp
2059         mov     %rsi,168($context)      # restore context->Rsi
2060         mov     %rdi,176($context)      # restore context->Rdi
2061
2062         mov     40($disp),%rdi          # disp->ContextRecord
2063         mov     $context,%rsi           # context
2064         mov     \$154,%ecx              # sizeof(CONTEXT)
2065         .long   0xa548f3fc              # cld; rep movsq
2066
2067         mov     $disp,%rsi
2068         xor     %rcx,%rcx               # arg1, UNW_FLAG_NHANDLER
2069         mov     8(%rsi),%rdx            # arg2, disp->ImageBase
2070         mov     0(%rsi),%r8             # arg3, disp->ControlPc
2071         mov     16(%rsi),%r9            # arg4, disp->FunctionEntry
2072         mov     40(%rsi),%r10           # disp->ContextRecord
2073         lea     56(%rsi),%r11           # &disp->HandlerData
2074         lea     24(%rsi),%r12           # &disp->EstablisherFrame
2075         mov     %r10,32(%rsp)           # arg5
2076         mov     %r11,40(%rsp)           # arg6
2077         mov     %r12,48(%rsp)           # arg7
2078         mov     %rcx,56(%rsp)           # arg8, (NULL)
2079         call    *__imp_RtlVirtualUnwind(%rip)
2080
2081         mov     \$1,%eax                # ExceptionContinueSearch
2082         add     \$64,%rsp
2083         popfq
2084         pop     %r15
2085         pop     %r14
2086         pop     %r13
2087         pop     %r12
2088         pop     %rbp
2089         pop     %rbx
2090         pop     %rdi
2091         pop     %rsi
2092         ret
2093 .size   sqr_handler,.-sqr_handler
2094
2095 .section        .pdata
2096 .align  4
2097         .rva    .LSEH_begin_rsaz_512_sqr
2098         .rva    .LSEH_end_rsaz_512_sqr
2099         .rva    .LSEH_info_rsaz_512_sqr
2100
2101         .rva    .LSEH_begin_rsaz_512_mul
2102         .rva    .LSEH_end_rsaz_512_mul
2103         .rva    .LSEH_info_rsaz_512_mul
2104
2105         .rva    .LSEH_begin_rsaz_512_mul_gather4
2106         .rva    .LSEH_end_rsaz_512_mul_gather4
2107         .rva    .LSEH_info_rsaz_512_mul_gather4
2108
2109         .rva    .LSEH_begin_rsaz_512_mul_scatter4
2110         .rva    .LSEH_end_rsaz_512_mul_scatter4
2111         .rva    .LSEH_info_rsaz_512_mul_scatter4
2112
2113         .rva    .LSEH_begin_rsaz_512_mul_by_one
2114         .rva    .LSEH_end_rsaz_512_mul_by_one
2115         .rva    .LSEH_info_rsaz_512_mul_by_one
2116
2117 .section        .xdata
2118 .align  8
2119 .LSEH_info_rsaz_512_sqr:
2120         .byte   9,0,0,0
2121         .rva    se_handler
2122         .rva    .Lsqr_body,.Lsqr_epilogue                       # HandlerData[]
2123 .LSEH_info_rsaz_512_mul:
2124         .byte   9,0,0,0
2125         .rva    se_handler
2126         .rva    .Lmul_body,.Lmul_epilogue                       # HandlerData[]
2127 .LSEH_info_rsaz_512_mul_gather4:
2128         .byte   9,0,0,0
2129         .rva    se_handler
2130         .rva    .Lmul_gather4_body,.Lmul_gather4_epilogue       # HandlerData[]
2131 .LSEH_info_rsaz_512_mul_scatter4:
2132         .byte   9,0,0,0
2133         .rva    se_handler
2134         .rva    .Lmul_scatter4_body,.Lmul_scatter4_epilogue     # HandlerData[]
2135 .LSEH_info_rsaz_512_mul_by_one:
2136         .byte   9,0,0,0
2137         .rva    se_handler
2138         .rva    .Lmul_by_one_body,.Lmul_by_one_epilogue         # HandlerData[]
2139 ___
2140 }
2141
2142 $code =~ s/\`([^\`]*)\`/eval $1/gem;
2143 print $code;
2144 close STDOUT;