ia64: allocate percpu area for cpu0 like percpu areas for other cpus
[linux-2.6.git] / arch / x86 / crypto / salsa20-x86_64-asm_64.S
1 # enter ECRYPT_encrypt_bytes
2 .text
3 .p2align 5
4 .globl ECRYPT_encrypt_bytes
5 ECRYPT_encrypt_bytes:
6         mov     %rsp,%r11
7         and     $31,%r11
8         add     $256,%r11
9         sub     %r11,%rsp
10         # x = arg1
11         mov     %rdi,%r8
12         # m = arg2
13         mov     %rsi,%rsi
14         # out = arg3
15         mov     %rdx,%rdi
16         # bytes = arg4
17         mov     %rcx,%rdx
18         #               unsigned>? bytes - 0
19         cmp     $0,%rdx
20         # comment:fp stack unchanged by jump
21         # goto done if !unsigned>
22         jbe     ._done
23         # comment:fp stack unchanged by fallthrough
24 # start:
25 ._start:
26         # r11_stack = r11
27         movq    %r11,0(%rsp)
28         # r12_stack = r12
29         movq    %r12,8(%rsp)
30         # r13_stack = r13
31         movq    %r13,16(%rsp)
32         # r14_stack = r14
33         movq    %r14,24(%rsp)
34         # r15_stack = r15
35         movq    %r15,32(%rsp)
36         # rbx_stack = rbx
37         movq    %rbx,40(%rsp)
38         # rbp_stack = rbp
39         movq    %rbp,48(%rsp)
40         # in0 = *(uint64 *) (x + 0)
41         movq    0(%r8),%rcx
42         # in2 = *(uint64 *) (x + 8)
43         movq    8(%r8),%r9
44         # in4 = *(uint64 *) (x + 16)
45         movq    16(%r8),%rax
46         # in6 = *(uint64 *) (x + 24)
47         movq    24(%r8),%r10
48         # in8 = *(uint64 *) (x + 32)
49         movq    32(%r8),%r11
50         # in10 = *(uint64 *) (x + 40)
51         movq    40(%r8),%r12
52         # in12 = *(uint64 *) (x + 48)
53         movq    48(%r8),%r13
54         # in14 = *(uint64 *) (x + 56)
55         movq    56(%r8),%r14
56         # j0 = in0
57         movq    %rcx,56(%rsp)
58         # j2 = in2
59         movq    %r9,64(%rsp)
60         # j4 = in4
61         movq    %rax,72(%rsp)
62         # j6 = in6
63         movq    %r10,80(%rsp)
64         # j8 = in8
65         movq    %r11,88(%rsp)
66         # j10 = in10
67         movq    %r12,96(%rsp)
68         # j12 = in12
69         movq    %r13,104(%rsp)
70         # j14 = in14
71         movq    %r14,112(%rsp)
72         # x_backup = x
73         movq    %r8,120(%rsp)
74 # bytesatleast1:
75 ._bytesatleast1:
76         #                   unsigned<? bytes - 64
77         cmp     $64,%rdx
78         # comment:fp stack unchanged by jump
79         #   goto nocopy if !unsigned<
80         jae     ._nocopy
81         #     ctarget = out
82         movq    %rdi,128(%rsp)
83         #     out = &tmp
84         leaq    192(%rsp),%rdi
85         #     i = bytes
86         mov     %rdx,%rcx
87         #     while (i) { *out++ = *m++; --i }
88         rep     movsb
89         #     out = &tmp
90         leaq    192(%rsp),%rdi
91         #     m = &tmp
92         leaq    192(%rsp),%rsi
93         # comment:fp stack unchanged by fallthrough
94 #   nocopy:
95 ._nocopy:
96         #   out_backup = out
97         movq    %rdi,136(%rsp)
98         #   m_backup = m
99         movq    %rsi,144(%rsp)
100         #   bytes_backup = bytes
101         movq    %rdx,152(%rsp)
102         #   x1 = j0
103         movq    56(%rsp),%rdi
104         #   x0 = x1
105         mov     %rdi,%rdx
106         #   (uint64) x1 >>= 32
107         shr     $32,%rdi
108         #               x3 = j2
109         movq    64(%rsp),%rsi
110         #               x2 = x3
111         mov     %rsi,%rcx
112         #               (uint64) x3 >>= 32
113         shr     $32,%rsi
114         #   x5 = j4
115         movq    72(%rsp),%r8
116         #   x4 = x5
117         mov     %r8,%r9
118         #   (uint64) x5 >>= 32
119         shr     $32,%r8
120         #   x5_stack = x5
121         movq    %r8,160(%rsp)
122         #               x7 = j6
123         movq    80(%rsp),%r8
124         #               x6 = x7
125         mov     %r8,%rax
126         #               (uint64) x7 >>= 32
127         shr     $32,%r8
128         #   x9 = j8
129         movq    88(%rsp),%r10
130         #   x8 = x9
131         mov     %r10,%r11
132         #   (uint64) x9 >>= 32
133         shr     $32,%r10
134         #               x11 = j10
135         movq    96(%rsp),%r12
136         #               x10 = x11
137         mov     %r12,%r13
138         #               x10_stack = x10
139         movq    %r13,168(%rsp)
140         #               (uint64) x11 >>= 32
141         shr     $32,%r12
142         #   x13 = j12
143         movq    104(%rsp),%r13
144         #   x12 = x13
145         mov     %r13,%r14
146         #   (uint64) x13 >>= 32
147         shr     $32,%r13
148         #               x15 = j14
149         movq    112(%rsp),%r15
150         #               x14 = x15
151         mov     %r15,%rbx
152         #               (uint64) x15 >>= 32
153         shr     $32,%r15
154         #               x15_stack = x15
155         movq    %r15,176(%rsp)
156         #   i = 20
157         mov     $20,%r15
158 #   mainloop:
159 ._mainloop:
160         #   i_backup = i
161         movq    %r15,184(%rsp)
162         #               x5 = x5_stack
163         movq    160(%rsp),%r15
164         # a = x12 + x0
165         lea     (%r14,%rdx),%rbp
166         # (uint32) a <<<= 7
167         rol     $7,%ebp
168         # x4 ^= a
169         xor     %rbp,%r9
170         #               b = x1 + x5
171         lea     (%rdi,%r15),%rbp
172         #               (uint32) b <<<= 7
173         rol     $7,%ebp
174         #               x9 ^= b
175         xor     %rbp,%r10
176         # a = x0 + x4
177         lea     (%rdx,%r9),%rbp
178         # (uint32) a <<<= 9
179         rol     $9,%ebp
180         # x8 ^= a
181         xor     %rbp,%r11
182         #               b = x5 + x9
183         lea     (%r15,%r10),%rbp
184         #               (uint32) b <<<= 9
185         rol     $9,%ebp
186         #               x13 ^= b
187         xor     %rbp,%r13
188         # a = x4 + x8
189         lea     (%r9,%r11),%rbp
190         # (uint32) a <<<= 13
191         rol     $13,%ebp
192         # x12 ^= a
193         xor     %rbp,%r14
194         #               b = x9 + x13
195         lea     (%r10,%r13),%rbp
196         #               (uint32) b <<<= 13
197         rol     $13,%ebp
198         #               x1 ^= b
199         xor     %rbp,%rdi
200         # a = x8 + x12
201         lea     (%r11,%r14),%rbp
202         # (uint32) a <<<= 18
203         rol     $18,%ebp
204         # x0 ^= a
205         xor     %rbp,%rdx
206         #               b = x13 + x1
207         lea     (%r13,%rdi),%rbp
208         #               (uint32) b <<<= 18
209         rol     $18,%ebp
210         #               x5 ^= b
211         xor     %rbp,%r15
212         #                               x10 = x10_stack
213         movq    168(%rsp),%rbp
214         #               x5_stack = x5
215         movq    %r15,160(%rsp)
216         #                               c = x6 + x10
217         lea     (%rax,%rbp),%r15
218         #                               (uint32) c <<<= 7
219         rol     $7,%r15d
220         #                               x14 ^= c
221         xor     %r15,%rbx
222         #                               c = x10 + x14
223         lea     (%rbp,%rbx),%r15
224         #                               (uint32) c <<<= 9
225         rol     $9,%r15d
226         #                               x2 ^= c
227         xor     %r15,%rcx
228         #                               c = x14 + x2
229         lea     (%rbx,%rcx),%r15
230         #                               (uint32) c <<<= 13
231         rol     $13,%r15d
232         #                               x6 ^= c
233         xor     %r15,%rax
234         #                               c = x2 + x6
235         lea     (%rcx,%rax),%r15
236         #                               (uint32) c <<<= 18
237         rol     $18,%r15d
238         #                               x10 ^= c
239         xor     %r15,%rbp
240         #                                               x15 = x15_stack
241         movq    176(%rsp),%r15
242         #                               x10_stack = x10
243         movq    %rbp,168(%rsp)
244         #                                               d = x11 + x15
245         lea     (%r12,%r15),%rbp
246         #                                               (uint32) d <<<= 7
247         rol     $7,%ebp
248         #                                               x3 ^= d
249         xor     %rbp,%rsi
250         #                                               d = x15 + x3
251         lea     (%r15,%rsi),%rbp
252         #                                               (uint32) d <<<= 9
253         rol     $9,%ebp
254         #                                               x7 ^= d
255         xor     %rbp,%r8
256         #                                               d = x3 + x7
257         lea     (%rsi,%r8),%rbp
258         #                                               (uint32) d <<<= 13
259         rol     $13,%ebp
260         #                                               x11 ^= d
261         xor     %rbp,%r12
262         #                                               d = x7 + x11
263         lea     (%r8,%r12),%rbp
264         #                                               (uint32) d <<<= 18
265         rol     $18,%ebp
266         #                                               x15 ^= d
267         xor     %rbp,%r15
268         #                                               x15_stack = x15
269         movq    %r15,176(%rsp)
270         #               x5 = x5_stack
271         movq    160(%rsp),%r15
272         # a = x3 + x0
273         lea     (%rsi,%rdx),%rbp
274         # (uint32) a <<<= 7
275         rol     $7,%ebp
276         # x1 ^= a
277         xor     %rbp,%rdi
278         #               b = x4 + x5
279         lea     (%r9,%r15),%rbp
280         #               (uint32) b <<<= 7
281         rol     $7,%ebp
282         #               x6 ^= b
283         xor     %rbp,%rax
284         # a = x0 + x1
285         lea     (%rdx,%rdi),%rbp
286         # (uint32) a <<<= 9
287         rol     $9,%ebp
288         # x2 ^= a
289         xor     %rbp,%rcx
290         #               b = x5 + x6
291         lea     (%r15,%rax),%rbp
292         #               (uint32) b <<<= 9
293         rol     $9,%ebp
294         #               x7 ^= b
295         xor     %rbp,%r8
296         # a = x1 + x2
297         lea     (%rdi,%rcx),%rbp
298         # (uint32) a <<<= 13
299         rol     $13,%ebp
300         # x3 ^= a
301         xor     %rbp,%rsi
302         #               b = x6 + x7
303         lea     (%rax,%r8),%rbp
304         #               (uint32) b <<<= 13
305         rol     $13,%ebp
306         #               x4 ^= b
307         xor     %rbp,%r9
308         # a = x2 + x3
309         lea     (%rcx,%rsi),%rbp
310         # (uint32) a <<<= 18
311         rol     $18,%ebp
312         # x0 ^= a
313         xor     %rbp,%rdx
314         #               b = x7 + x4
315         lea     (%r8,%r9),%rbp
316         #               (uint32) b <<<= 18
317         rol     $18,%ebp
318         #               x5 ^= b
319         xor     %rbp,%r15
320         #                               x10 = x10_stack
321         movq    168(%rsp),%rbp
322         #               x5_stack = x5
323         movq    %r15,160(%rsp)
324         #                               c = x9 + x10
325         lea     (%r10,%rbp),%r15
326         #                               (uint32) c <<<= 7
327         rol     $7,%r15d
328         #                               x11 ^= c
329         xor     %r15,%r12
330         #                               c = x10 + x11
331         lea     (%rbp,%r12),%r15
332         #                               (uint32) c <<<= 9
333         rol     $9,%r15d
334         #                               x8 ^= c
335         xor     %r15,%r11
336         #                               c = x11 + x8
337         lea     (%r12,%r11),%r15
338         #                               (uint32) c <<<= 13
339         rol     $13,%r15d
340         #                               x9 ^= c
341         xor     %r15,%r10
342         #                               c = x8 + x9
343         lea     (%r11,%r10),%r15
344         #                               (uint32) c <<<= 18
345         rol     $18,%r15d
346         #                               x10 ^= c
347         xor     %r15,%rbp
348         #                                               x15 = x15_stack
349         movq    176(%rsp),%r15
350         #                               x10_stack = x10
351         movq    %rbp,168(%rsp)
352         #                                               d = x14 + x15
353         lea     (%rbx,%r15),%rbp
354         #                                               (uint32) d <<<= 7
355         rol     $7,%ebp
356         #                                               x12 ^= d
357         xor     %rbp,%r14
358         #                                               d = x15 + x12
359         lea     (%r15,%r14),%rbp
360         #                                               (uint32) d <<<= 9
361         rol     $9,%ebp
362         #                                               x13 ^= d
363         xor     %rbp,%r13
364         #                                               d = x12 + x13
365         lea     (%r14,%r13),%rbp
366         #                                               (uint32) d <<<= 13
367         rol     $13,%ebp
368         #                                               x14 ^= d
369         xor     %rbp,%rbx
370         #                                               d = x13 + x14
371         lea     (%r13,%rbx),%rbp
372         #                                               (uint32) d <<<= 18
373         rol     $18,%ebp
374         #                                               x15 ^= d
375         xor     %rbp,%r15
376         #                                               x15_stack = x15
377         movq    %r15,176(%rsp)
378         #               x5 = x5_stack
379         movq    160(%rsp),%r15
380         # a = x12 + x0
381         lea     (%r14,%rdx),%rbp
382         # (uint32) a <<<= 7
383         rol     $7,%ebp
384         # x4 ^= a
385         xor     %rbp,%r9
386         #               b = x1 + x5
387         lea     (%rdi,%r15),%rbp
388         #               (uint32) b <<<= 7
389         rol     $7,%ebp
390         #               x9 ^= b
391         xor     %rbp,%r10
392         # a = x0 + x4
393         lea     (%rdx,%r9),%rbp
394         # (uint32) a <<<= 9
395         rol     $9,%ebp
396         # x8 ^= a
397         xor     %rbp,%r11
398         #               b = x5 + x9
399         lea     (%r15,%r10),%rbp
400         #               (uint32) b <<<= 9
401         rol     $9,%ebp
402         #               x13 ^= b
403         xor     %rbp,%r13
404         # a = x4 + x8
405         lea     (%r9,%r11),%rbp
406         # (uint32) a <<<= 13
407         rol     $13,%ebp
408         # x12 ^= a
409         xor     %rbp,%r14
410         #               b = x9 + x13
411         lea     (%r10,%r13),%rbp
412         #               (uint32) b <<<= 13
413         rol     $13,%ebp
414         #               x1 ^= b
415         xor     %rbp,%rdi
416         # a = x8 + x12
417         lea     (%r11,%r14),%rbp
418         # (uint32) a <<<= 18
419         rol     $18,%ebp
420         # x0 ^= a
421         xor     %rbp,%rdx
422         #               b = x13 + x1
423         lea     (%r13,%rdi),%rbp
424         #               (uint32) b <<<= 18
425         rol     $18,%ebp
426         #               x5 ^= b
427         xor     %rbp,%r15
428         #                               x10 = x10_stack
429         movq    168(%rsp),%rbp
430         #               x5_stack = x5
431         movq    %r15,160(%rsp)
432         #                               c = x6 + x10
433         lea     (%rax,%rbp),%r15
434         #                               (uint32) c <<<= 7
435         rol     $7,%r15d
436         #                               x14 ^= c
437         xor     %r15,%rbx
438         #                               c = x10 + x14
439         lea     (%rbp,%rbx),%r15
440         #                               (uint32) c <<<= 9
441         rol     $9,%r15d
442         #                               x2 ^= c
443         xor     %r15,%rcx
444         #                               c = x14 + x2
445         lea     (%rbx,%rcx),%r15
446         #                               (uint32) c <<<= 13
447         rol     $13,%r15d
448         #                               x6 ^= c
449         xor     %r15,%rax
450         #                               c = x2 + x6
451         lea     (%rcx,%rax),%r15
452         #                               (uint32) c <<<= 18
453         rol     $18,%r15d
454         #                               x10 ^= c
455         xor     %r15,%rbp
456         #                                               x15 = x15_stack
457         movq    176(%rsp),%r15
458         #                               x10_stack = x10
459         movq    %rbp,168(%rsp)
460         #                                               d = x11 + x15
461         lea     (%r12,%r15),%rbp
462         #                                               (uint32) d <<<= 7
463         rol     $7,%ebp
464         #                                               x3 ^= d
465         xor     %rbp,%rsi
466         #                                               d = x15 + x3
467         lea     (%r15,%rsi),%rbp
468         #                                               (uint32) d <<<= 9
469         rol     $9,%ebp
470         #                                               x7 ^= d
471         xor     %rbp,%r8
472         #                                               d = x3 + x7
473         lea     (%rsi,%r8),%rbp
474         #                                               (uint32) d <<<= 13
475         rol     $13,%ebp
476         #                                               x11 ^= d
477         xor     %rbp,%r12
478         #                                               d = x7 + x11
479         lea     (%r8,%r12),%rbp
480         #                                               (uint32) d <<<= 18
481         rol     $18,%ebp
482         #                                               x15 ^= d
483         xor     %rbp,%r15
484         #                                               x15_stack = x15
485         movq    %r15,176(%rsp)
486         #               x5 = x5_stack
487         movq    160(%rsp),%r15
488         # a = x3 + x0
489         lea     (%rsi,%rdx),%rbp
490         # (uint32) a <<<= 7
491         rol     $7,%ebp
492         # x1 ^= a
493         xor     %rbp,%rdi
494         #               b = x4 + x5
495         lea     (%r9,%r15),%rbp
496         #               (uint32) b <<<= 7
497         rol     $7,%ebp
498         #               x6 ^= b
499         xor     %rbp,%rax
500         # a = x0 + x1
501         lea     (%rdx,%rdi),%rbp
502         # (uint32) a <<<= 9
503         rol     $9,%ebp
504         # x2 ^= a
505         xor     %rbp,%rcx
506         #               b = x5 + x6
507         lea     (%r15,%rax),%rbp
508         #               (uint32) b <<<= 9
509         rol     $9,%ebp
510         #               x7 ^= b
511         xor     %rbp,%r8
512         # a = x1 + x2
513         lea     (%rdi,%rcx),%rbp
514         # (uint32) a <<<= 13
515         rol     $13,%ebp
516         # x3 ^= a
517         xor     %rbp,%rsi
518         #               b = x6 + x7
519         lea     (%rax,%r8),%rbp
520         #               (uint32) b <<<= 13
521         rol     $13,%ebp
522         #               x4 ^= b
523         xor     %rbp,%r9
524         # a = x2 + x3
525         lea     (%rcx,%rsi),%rbp
526         # (uint32) a <<<= 18
527         rol     $18,%ebp
528         # x0 ^= a
529         xor     %rbp,%rdx
530         #               b = x7 + x4
531         lea     (%r8,%r9),%rbp
532         #               (uint32) b <<<= 18
533         rol     $18,%ebp
534         #               x5 ^= b
535         xor     %rbp,%r15
536         #                               x10 = x10_stack
537         movq    168(%rsp),%rbp
538         #               x5_stack = x5
539         movq    %r15,160(%rsp)
540         #                               c = x9 + x10
541         lea     (%r10,%rbp),%r15
542         #                               (uint32) c <<<= 7
543         rol     $7,%r15d
544         #                               x11 ^= c
545         xor     %r15,%r12
546         #                               c = x10 + x11
547         lea     (%rbp,%r12),%r15
548         #                               (uint32) c <<<= 9
549         rol     $9,%r15d
550         #                               x8 ^= c
551         xor     %r15,%r11
552         #                               c = x11 + x8
553         lea     (%r12,%r11),%r15
554         #                               (uint32) c <<<= 13
555         rol     $13,%r15d
556         #                               x9 ^= c
557         xor     %r15,%r10
558         #                               c = x8 + x9
559         lea     (%r11,%r10),%r15
560         #                               (uint32) c <<<= 18
561         rol     $18,%r15d
562         #                               x10 ^= c
563         xor     %r15,%rbp
564         #                                               x15 = x15_stack
565         movq    176(%rsp),%r15
566         #                               x10_stack = x10
567         movq    %rbp,168(%rsp)
568         #                                               d = x14 + x15
569         lea     (%rbx,%r15),%rbp
570         #                                               (uint32) d <<<= 7
571         rol     $7,%ebp
572         #                                               x12 ^= d
573         xor     %rbp,%r14
574         #                                               d = x15 + x12
575         lea     (%r15,%r14),%rbp
576         #                                               (uint32) d <<<= 9
577         rol     $9,%ebp
578         #                                               x13 ^= d
579         xor     %rbp,%r13
580         #                                               d = x12 + x13
581         lea     (%r14,%r13),%rbp
582         #                                               (uint32) d <<<= 13
583         rol     $13,%ebp
584         #                                               x14 ^= d
585         xor     %rbp,%rbx
586         #                                               d = x13 + x14
587         lea     (%r13,%rbx),%rbp
588         #                                               (uint32) d <<<= 18
589         rol     $18,%ebp
590         #                                               x15 ^= d
591         xor     %rbp,%r15
592         #                                               x15_stack = x15
593         movq    %r15,176(%rsp)
594         #   i = i_backup
595         movq    184(%rsp),%r15
596         #                  unsigned>? i -= 4
597         sub     $4,%r15
598         # comment:fp stack unchanged by jump
599         # goto mainloop if unsigned>
600         ja      ._mainloop
601         #   (uint32) x2 += j2
602         addl    64(%rsp),%ecx
603         #   x3 <<= 32
604         shl     $32,%rsi
605         #   x3 += j2
606         addq    64(%rsp),%rsi
607         #   (uint64) x3 >>= 32
608         shr     $32,%rsi
609         #   x3 <<= 32
610         shl     $32,%rsi
611         #   x2 += x3
612         add     %rsi,%rcx
613         #   (uint32) x6 += j6
614         addl    80(%rsp),%eax
615         #   x7 <<= 32
616         shl     $32,%r8
617         #   x7 += j6
618         addq    80(%rsp),%r8
619         #   (uint64) x7 >>= 32
620         shr     $32,%r8
621         #   x7 <<= 32
622         shl     $32,%r8
623         #   x6 += x7
624         add     %r8,%rax
625         #   (uint32) x8 += j8
626         addl    88(%rsp),%r11d
627         #   x9 <<= 32
628         shl     $32,%r10
629         #   x9 += j8
630         addq    88(%rsp),%r10
631         #   (uint64) x9 >>= 32
632         shr     $32,%r10
633         #   x9 <<= 32
634         shl     $32,%r10
635         #   x8 += x9
636         add     %r10,%r11
637         #   (uint32) x12 += j12
638         addl    104(%rsp),%r14d
639         #   x13 <<= 32
640         shl     $32,%r13
641         #   x13 += j12
642         addq    104(%rsp),%r13
643         #   (uint64) x13 >>= 32
644         shr     $32,%r13
645         #   x13 <<= 32
646         shl     $32,%r13
647         #   x12 += x13
648         add     %r13,%r14
649         #   (uint32) x0 += j0
650         addl    56(%rsp),%edx
651         #   x1 <<= 32
652         shl     $32,%rdi
653         #   x1 += j0
654         addq    56(%rsp),%rdi
655         #   (uint64) x1 >>= 32
656         shr     $32,%rdi
657         #   x1 <<= 32
658         shl     $32,%rdi
659         #   x0 += x1
660         add     %rdi,%rdx
661         #   x5 = x5_stack
662         movq    160(%rsp),%rdi
663         #   (uint32) x4 += j4
664         addl    72(%rsp),%r9d
665         #   x5 <<= 32
666         shl     $32,%rdi
667         #   x5 += j4
668         addq    72(%rsp),%rdi
669         #   (uint64) x5 >>= 32
670         shr     $32,%rdi
671         #   x5 <<= 32
672         shl     $32,%rdi
673         #   x4 += x5
674         add     %rdi,%r9
675         #   x10 = x10_stack
676         movq    168(%rsp),%r8
677         #   (uint32) x10 += j10
678         addl    96(%rsp),%r8d
679         #   x11 <<= 32
680         shl     $32,%r12
681         #   x11 += j10
682         addq    96(%rsp),%r12
683         #   (uint64) x11 >>= 32
684         shr     $32,%r12
685         #   x11 <<= 32
686         shl     $32,%r12
687         #   x10 += x11
688         add     %r12,%r8
689         #   x15 = x15_stack
690         movq    176(%rsp),%rdi
691         #   (uint32) x14 += j14
692         addl    112(%rsp),%ebx
693         #   x15 <<= 32
694         shl     $32,%rdi
695         #   x15 += j14
696         addq    112(%rsp),%rdi
697         #   (uint64) x15 >>= 32
698         shr     $32,%rdi
699         #   x15 <<= 32
700         shl     $32,%rdi
701         #   x14 += x15
702         add     %rdi,%rbx
703         #   out = out_backup
704         movq    136(%rsp),%rdi
705         #   m = m_backup
706         movq    144(%rsp),%rsi
707         #   x0 ^= *(uint64 *) (m + 0)
708         xorq    0(%rsi),%rdx
709         #   *(uint64 *) (out + 0) = x0
710         movq    %rdx,0(%rdi)
711         #   x2 ^= *(uint64 *) (m + 8)
712         xorq    8(%rsi),%rcx
713         #   *(uint64 *) (out + 8) = x2
714         movq    %rcx,8(%rdi)
715         #   x4 ^= *(uint64 *) (m + 16)
716         xorq    16(%rsi),%r9
717         #   *(uint64 *) (out + 16) = x4
718         movq    %r9,16(%rdi)
719         #   x6 ^= *(uint64 *) (m + 24)
720         xorq    24(%rsi),%rax
721         #   *(uint64 *) (out + 24) = x6
722         movq    %rax,24(%rdi)
723         #   x8 ^= *(uint64 *) (m + 32)
724         xorq    32(%rsi),%r11
725         #   *(uint64 *) (out + 32) = x8
726         movq    %r11,32(%rdi)
727         #   x10 ^= *(uint64 *) (m + 40)
728         xorq    40(%rsi),%r8
729         #   *(uint64 *) (out + 40) = x10
730         movq    %r8,40(%rdi)
731         #   x12 ^= *(uint64 *) (m + 48)
732         xorq    48(%rsi),%r14
733         #   *(uint64 *) (out + 48) = x12
734         movq    %r14,48(%rdi)
735         #   x14 ^= *(uint64 *) (m + 56)
736         xorq    56(%rsi),%rbx
737         #   *(uint64 *) (out + 56) = x14
738         movq    %rbx,56(%rdi)
739         #   bytes = bytes_backup
740         movq    152(%rsp),%rdx
741         #   in8 = j8
742         movq    88(%rsp),%rcx
743         #   in8 += 1
744         add     $1,%rcx
745         #   j8 = in8
746         movq    %rcx,88(%rsp)
747         #                          unsigned>? unsigned<? bytes - 64
748         cmp     $64,%rdx
749         # comment:fp stack unchanged by jump
750         #   goto bytesatleast65 if unsigned>
751         ja      ._bytesatleast65
752         # comment:fp stack unchanged by jump
753         #     goto bytesatleast64 if !unsigned<
754         jae     ._bytesatleast64
755         #       m = out
756         mov     %rdi,%rsi
757         #       out = ctarget
758         movq    128(%rsp),%rdi
759         #       i = bytes
760         mov     %rdx,%rcx
761         #       while (i) { *out++ = *m++; --i }
762         rep     movsb
763         # comment:fp stack unchanged by fallthrough
764 #     bytesatleast64:
765 ._bytesatleast64:
766         #     x = x_backup
767         movq    120(%rsp),%rdi
768         #     in8 = j8
769         movq    88(%rsp),%rsi
770         #     *(uint64 *) (x + 32) = in8
771         movq    %rsi,32(%rdi)
772         #     r11 = r11_stack
773         movq    0(%rsp),%r11
774         #     r12 = r12_stack
775         movq    8(%rsp),%r12
776         #     r13 = r13_stack
777         movq    16(%rsp),%r13
778         #     r14 = r14_stack
779         movq    24(%rsp),%r14
780         #     r15 = r15_stack
781         movq    32(%rsp),%r15
782         #     rbx = rbx_stack
783         movq    40(%rsp),%rbx
784         #     rbp = rbp_stack
785         movq    48(%rsp),%rbp
786         # comment:fp stack unchanged by fallthrough
787 #     done:
788 ._done:
789         #     leave
790         add     %r11,%rsp
791         mov     %rdi,%rax
792         mov     %rsi,%rdx
793         ret
794 #   bytesatleast65:
795 ._bytesatleast65:
796         #   bytes -= 64
797         sub     $64,%rdx
798         #   out += 64
799         add     $64,%rdi
800         #   m += 64
801         add     $64,%rsi
802         # comment:fp stack unchanged by jump
803         # goto bytesatleast1
804         jmp     ._bytesatleast1
805 # enter ECRYPT_keysetup
806 .text
807 .p2align 5
808 .globl ECRYPT_keysetup
809 ECRYPT_keysetup:
810         mov     %rsp,%r11
811         and     $31,%r11
812         add     $256,%r11
813         sub     %r11,%rsp
814         #   k = arg2
815         mov     %rsi,%rsi
816         #   kbits = arg3
817         mov     %rdx,%rdx
818         #   x = arg1
819         mov     %rdi,%rdi
820         #   in0 = *(uint64 *) (k + 0)
821         movq    0(%rsi),%r8
822         #   in2 = *(uint64 *) (k + 8)
823         movq    8(%rsi),%r9
824         #   *(uint64 *) (x + 4) = in0
825         movq    %r8,4(%rdi)
826         #   *(uint64 *) (x + 12) = in2
827         movq    %r9,12(%rdi)
828         #                    unsigned<? kbits - 256
829         cmp     $256,%rdx
830         # comment:fp stack unchanged by jump
831         #   goto kbits128 if unsigned<
832         jb      ._kbits128
833 #   kbits256:
834 ._kbits256:
835         #     in10 = *(uint64 *) (k + 16)
836         movq    16(%rsi),%rdx
837         #     in12 = *(uint64 *) (k + 24)
838         movq    24(%rsi),%rsi
839         #     *(uint64 *) (x + 44) = in10
840         movq    %rdx,44(%rdi)
841         #     *(uint64 *) (x + 52) = in12
842         movq    %rsi,52(%rdi)
843         #     in0 = 1634760805
844         mov     $1634760805,%rsi
845         #     in4 = 857760878
846         mov     $857760878,%rdx
847         #     in10 = 2036477234
848         mov     $2036477234,%rcx
849         #     in14 = 1797285236
850         mov     $1797285236,%r8
851         #     *(uint32 *) (x + 0) = in0
852         movl    %esi,0(%rdi)
853         #     *(uint32 *) (x + 20) = in4
854         movl    %edx,20(%rdi)
855         #     *(uint32 *) (x + 40) = in10
856         movl    %ecx,40(%rdi)
857         #     *(uint32 *) (x + 60) = in14
858         movl    %r8d,60(%rdi)
859         # comment:fp stack unchanged by jump
860         #   goto keysetupdone
861         jmp     ._keysetupdone
862 #   kbits128:
863 ._kbits128:
864         #     in10 = *(uint64 *) (k + 0)
865         movq    0(%rsi),%rdx
866         #     in12 = *(uint64 *) (k + 8)
867         movq    8(%rsi),%rsi
868         #     *(uint64 *) (x + 44) = in10
869         movq    %rdx,44(%rdi)
870         #     *(uint64 *) (x + 52) = in12
871         movq    %rsi,52(%rdi)
872         #     in0 = 1634760805
873         mov     $1634760805,%rsi
874         #     in4 = 824206446
875         mov     $824206446,%rdx
876         #     in10 = 2036477238
877         mov     $2036477238,%rcx
878         #     in14 = 1797285236
879         mov     $1797285236,%r8
880         #     *(uint32 *) (x + 0) = in0
881         movl    %esi,0(%rdi)
882         #     *(uint32 *) (x + 20) = in4
883         movl    %edx,20(%rdi)
884         #     *(uint32 *) (x + 40) = in10
885         movl    %ecx,40(%rdi)
886         #     *(uint32 *) (x + 60) = in14
887         movl    %r8d,60(%rdi)
888 #   keysetupdone:
889 ._keysetupdone:
890         # leave
891         add     %r11,%rsp
892         mov     %rdi,%rax
893         mov     %rsi,%rdx
894         ret
895 # enter ECRYPT_ivsetup
896 .text
897 .p2align 5
898 .globl ECRYPT_ivsetup
899 ECRYPT_ivsetup:
900         mov     %rsp,%r11
901         and     $31,%r11
902         add     $256,%r11
903         sub     %r11,%rsp
904         #   iv = arg2
905         mov     %rsi,%rsi
906         #   x = arg1
907         mov     %rdi,%rdi
908         #   in6 = *(uint64 *) (iv + 0)
909         movq    0(%rsi),%rsi
910         #   in8 = 0
911         mov     $0,%r8
912         #   *(uint64 *) (x + 24) = in6
913         movq    %rsi,24(%rdi)
914         #   *(uint64 *) (x + 32) = in8
915         movq    %r8,32(%rdi)
916         # leave
917         add     %r11,%rsp
918         mov     %rdi,%rax
919         mov     %rsi,%rdx
920         ret