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