CoCalc -- salsa20-x86_64-asm

GitHub Repository: awilliam/linux-vfio
Path: blob/master/arch/x86/crypto/salsa20-x86_64-asm_64.S
¹⁰⁸¹⁷ views
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
921

922
Product

Resources

Company
