path: root/arch/x86/crypto/salsa20-x86_64-asm_64.S

# enter ECRYPT_encrypt_bytes
.text
.p2align 5
.globl ECRYPT_encrypt_bytes
ECRYPT_encrypt_bytes:
	mov	%rsp,%r11
	and	$31,%r11
	add	$256,%r11
	sub	%r11,%rsp
	# x = arg1
	mov	%rdi,%r8
	# m = arg2
	mov	%rsi,%rsi
	# out = arg3
	mov	%rdx,%rdi
	# bytes = arg4
	mov	%rcx,%rdx
	#               unsigned>? bytes - 0
	cmp	$0,%rdx
	# comment:fp stack unchanged by jump
	# goto done if !unsigned>
	jbe	._done
	# comment:fp stack unchanged by fallthrough
# start:
._start:
	# r11_stack = r11
	movq	%r11,0(%rsp)
	# r12_stack = r12
	movq	%r12,8(%rsp)
	# r13_stack = r13
	movq	%r13,16(%rsp)
	# r14_stack = r14
	movq	%r14,24(%rsp)
	# r15_stack = r15
	movq	%r15,32(%rsp)
	# rbx_stack = rbx
	movq	%rbx,40(%rsp)
	# rbp_stack = rbp
	movq	%rbp,48(%rsp)
	# in0 = *(uint64 *) (x + 0)
	movq	0(%r8),%rcx
	# in2 = *(uint64 *) (x + 8)
	movq	8(%r8),%r9
	# in4 = *(uint64 *) (x + 16)
	movq	16(%r8),%rax
	# in6 = *(uint64 *) (x + 24)
	movq	24(%r8),%r10
	# in8 = *(uint64 *) (x + 32)
	movq	32(%r8),%r11
	# in10 = *(uint64 *) (x + 40)
	movq	40(%r8),%r12
	# in12 = *(uint64 *) (x + 48)
	movq	48(%r8),%r13
	# in14 = *(uint64 *) (x + 56)
	movq	56(%r8),%r14
	# j0 = in0
	movq	%rcx,56(%rsp)
	# j2 = in2
	movq	%r9,64(%rsp)
	# j4 = in4
	movq	%rax,72(%rsp)
	# j6 = in6
	movq	%r10,80(%rsp)
	# j8 = in8
	movq	%r11,88(%rsp)
	# j10 = in10
	movq	%r12,96(%rsp)
	# j12 = in12
	movq	%r13,104(%rsp)
	# j14 = in14
	movq	%r14,112(%rsp)
	# x_backup = x
	movq	%r8,120(%rsp)
# bytesatleast1:
._bytesatleast1:
	#                   unsigned<? bytes - 64
	cmp	$64,%rdx
	# comment:fp stack unchanged by jump
	#   goto nocopy if !unsigned<
	jae	._nocopy
	#     ctarget = out
	movq	%rdi,128(%rsp)
	#     out = &tmp
	leaq	192(%rsp),%rdi
	#     i = bytes
	mov	%rdx,%rcx
	#     while (i) { *out++ = *m++; --i }
	rep	movsb
	#     out = &tmp
	leaq	192(%rsp),%rdi
	#     m = &tmp
	leaq	192(%rsp),%rsi
	# comment:fp stack unchanged by fallthrough
#   nocopy:
._nocopy:
	#   out_backup = out
	movq	%rdi,136(%rsp)
	#   m_backup = m
	movq	%rsi,144(%rsp)
	#   bytes_backup = bytes
	movq	%rdx,152(%rsp)
	#   x1 = j0
	movq	56(%rsp),%rdi
	#   x0 = x1
	mov	%rdi,%rdx
	#   (uint64) x1 >>= 32
	shr	$32,%rdi
	#   		x3 = j2
	movq	64(%rsp),%rsi
	#   		x2 = x3
	mov	%rsi,%rcx
	#   		(uint64) x3 >>= 32
	shr	$32,%rsi
	#   x5 = j4
	movq	72(%rsp),%r8
	#   x4 = x5
	mov	%r8,%r9
	#   (uint64) x5 >>= 32
	shr	$32,%r8
	#   x5_stack = x5
	movq	%r8,160(%rsp)
	#   		x7 = j6
	movq	80(%rsp),%r8
	#   		x6 = x7
	mov	%r8,%rax
	#   		(uint64) x7 >>= 32
	shr	$32,%r8
	#   x9 = j8
	movq	88(%rsp),%r10
	#   x8 = x9
	mov	%r10,%r11
	#   (uint64) x9 >>= 32
	shr	$32,%r10
	#   		x11 = j10
	movq	96(%rsp),%r12
	#   		x10 = x11
	mov	%r12,%r13
	#   		x10_stack = x10
	movq	%r13,168(%rsp)
	#   		(uint64) x11 >>= 32
	shr	$32,%r12
	#   x13 = j12
	movq	104(%rsp),%r13
	#   x12 = x13
	mov	%r13,%r14
	#   (uint64) x13 >>= 32
	shr	$32,%r13
	#   		x15 = j14
	movq	112(%rsp),%r15
	#   		x14 = x15
	mov	%r15,%rbx
	#   		(uint64) x15 >>= 32
	shr	$32,%r15
	#   		x15_stack = x15
	movq	%r15,176(%rsp)
	#   i = 20
	mov	$20,%r15
#   mainloop:
._mainloop:
	#   i_backup = i
	movq	%r15,184(%rsp)
	# 		x5 = x5_stack
	movq	160(%rsp),%r15
	# a = x12 + x0
	lea	(%r14,%rdx),%rbp
	# (uint32) a <<<= 7
	rol	$7,%ebp
	# x4 ^= a
	xor	%rbp,%r9
	# 		b = x1 + x5
	lea	(%rdi,%r15),%rbp
	# 		(uint32) b <<<= 7
	rol	$7,%ebp
	# 		x9 ^= b
	xor	%rbp,%r10
	# a = x0 + x4
	lea	(%rdx,%r9),%rbp
	# (uint32) a <<<= 9
	rol	$9,%ebp
	# x8 ^= a
	xor	%rbp,%r11
	# 		b = x5 + x9
	lea	(%r15,%r10),%rbp
	# 		(uint32) b <<<= 9
	rol	$9,%ebp
	# 		x13 ^= b
	xor	%rbp,%r13
	# a = x4 + x8
	lea	(%r9,%r11),%rbp
	# (uint32) a <<<= 13
	rol	$13,%ebp
	# x12 ^= a
	xor	%rbp,%r14
	# 		b = x9 + x13
	lea	(%r10,%r13),%rbp
	# 		(uint32) b <<<= 13
	rol	$13,%ebp
	# 		x1 ^= b
	xor	%rbp,%rdi
	# a = x8 + x12
	lea	(%r11,%r14),%rbp
	# (uint32) a <<<= 18
	rol	$18,%ebp
	# x0 ^= a
	xor	%rbp,%rdx
	# 		b = x13 + x1
	lea	(%r13,%rdi),%rbp