Powered by ViewCVS 1.0-dev
* imported additional implementations.
# qhasm: int64 a
# qhasm: int64 b
# qhasm: int64 c
# qhasm: int64 d
# qhasm: int64 e
# qhasm: int64 A
# qhasm: int64 B
# qhasm: int64 C
# qhasm: int64 D
# qhasm: int64 E
# qhasm: int64 r
# qhasm: int64 s
# qhasm: int64 t
# qhasm: int64 u
# qhasm: int64 v
# qhasm: int64 R
# qhasm: int64 S
# qhasm: int64 T
# qhasm: int64 U
# qhasm: int64 V
# qhasm: int64 arg1
# qhasm: int64 arg2
# qhasm: int64 arg3
# qhasm: int64 arg4
# qhasm: input arg1
# qhasm: input arg2
# qhasm: input arg3
# qhasm: input arg4
# qhasm: int64 r11
# qhasm: int64 r12
# qhasm: int64 r13
# qhasm: int64 r14
# qhasm: int64 r15
# qhasm: int64 rbx
# qhasm: int64 rbp
# qhasm: caller r11
# qhasm: caller r12
# qhasm: caller r13
# qhasm: caller r14
# qhasm: caller r15
# qhasm: caller rbx
# qhasm: caller rbp
# qhasm: stack64 r11_stack
# qhasm: stack64 r12_stack
# qhasm: stack64 r13_stack
# qhasm: stack64 r14_stack
# qhasm: stack64 r15_stack
# qhasm: stack64 rbx_stack
# qhasm: stack64 rbp_stack
# qhasm: int64 k
# qhasm: int64 kbits
# qhasm: int64 iv
# qhasm: int64 i
# qhasm: stack64 x_backup
# qhasm: int64 x
# qhasm: stack64 m_backup
# qhasm: int64 m
# qhasm: stack64 out_backup
# qhasm: int64 out
# qhasm: stack64 bytes_backup
# qhasm: int64 bytes
# qhasm: int64 in0
# qhasm: int64 in2
# qhasm: int64 in4
# qhasm: int64 in6
# qhasm: int64 in8
# qhasm: int64 in10
# qhasm: int64 in12
# qhasm: int64 in14
# qhasm: int64 out0
# qhasm: int64 out2
# qhasm: int64 out4
# qhasm: int64 out6
# qhasm: int64 out8
# qhasm: int64 out10
# qhasm: int64 out12
# qhasm: int64 out14
# qhasm: stack64 x0
# qhasm: stack64 x1
# qhasm: stack64 x2
# qhasm: stack64 x3
# qhasm: stack64 x4
# qhasm: stack64 x5
# qhasm: stack64 x6
# qhasm: stack64 x7
# qhasm: stack64 x8
# qhasm: stack64 x9
# qhasm: stack64 x10
# qhasm: stack64 x11
# qhasm: stack64 x12
# qhasm: stack64 x13
# qhasm: stack64 x14
# qhasm: stack64 x15
# qhasm: stack64 j0
# qhasm: stack64 j2
# qhasm: stack64 j4
# qhasm: stack64 j6
# qhasm: stack64 j8
# qhasm: stack64 j10
# qhasm: stack64 j12
# qhasm: stack64 j14
# qhasm: stack512 tmp
# qhasm: int64 ctarget
# qhasm: enter ECRYPT_keystream_bytes
.text
.p2align 5
.globl _ECRYPT_keystream_bytes
.globl ECRYPT_keystream_bytes
_ECRYPT_keystream_bytes:
ECRYPT_keystream_bytes:
mov %rsp,%r11
and $31,%r11
add $352,%r11
sub %r11,%rsp
# qhasm: x = arg1
# asm 1: mov <arg1=int64#1,>x=int64#5
# asm 2: mov <arg1=%rdi,>x=%r8
mov %rdi,%r8
# qhasm: m = arg2
# asm 1: mov <arg2=int64#2,>m=int64#2
# asm 2: mov <arg2=%rsi,>m=%rsi
mov %rsi,%rsi
# qhasm: out = m
# asm 1: mov <m=int64#2,>out=int64#1
# asm 2: mov <m=%rsi,>out=%rdi
mov %rsi,%rdi
# qhasm: bytes = arg3
# asm 1: mov <arg3=int64#3,>bytes=int64#3
# asm 2: mov <arg3=%rdx,>bytes=%rdx
mov %rdx,%rdx
# qhasm: unsigned>? bytes - 0
# asm 1: cmp $0,<bytes=int64#3
# asm 2: cmp $0,<bytes=%rdx
cmp $0,%rdx
# comment:fp stack unchanged by jump
# qhasm: goto done if !unsigned>
jbe ._done
# qhasm: a = 0
# asm 1: mov $0,>a=int64#7
# asm 2: mov $0,>a=%rax
mov $0,%rax
# qhasm: i = bytes
# asm 1: mov <bytes=int64#3,>i=int64#4
# asm 2: mov <bytes=%rdx,>i=%rcx
mov %rdx,%rcx
# qhasm: while (i) { *out++ = a; --i }
rep stosb
# qhasm: out -= bytes
# asm 1: sub <bytes=int64#3,<out=int64#1
# asm 2: sub <bytes=%rdx,<out=%rdi
sub %rdx,%rdi
# comment:fp stack unchanged by jump
# qhasm: goto start
jmp ._start
# qhasm: enter ECRYPT_decrypt_bytes
.text
.p2align 5
.globl _ECRYPT_decrypt_bytes
.globl ECRYPT_decrypt_bytes
_ECRYPT_decrypt_bytes:
ECRYPT_decrypt_bytes:
mov %rsp,%r11
and $31,%r11
add $352,%r11
sub %r11,%rsp
# qhasm: x = arg1
# asm 1: mov <arg1=int64#1,>x=int64#5
# asm 2: mov <arg1=%rdi,>x=%r8
mov %rdi,%r8
# qhasm: m = arg2
# asm 1: mov <arg2=int64#2,>m=int64#2
# asm 2: mov <arg2=%rsi,>m=%rsi
mov %rsi,%rsi
# qhasm: out = arg3
# asm 1: mov <arg3=int64#3,>out=int64#1
# asm 2: mov <arg3=%rdx,>out=%rdi
mov %rdx,%rdi
# qhasm: bytes = arg4
# asm 1: mov <arg4=int64#4,>bytes=int64#3
# asm 2: mov <arg4=%rcx,>bytes=%rdx
mov %rcx,%rdx
# qhasm: unsigned>? bytes - 0
# asm 1: cmp $0,<bytes=int64#3
# asm 2: cmp $0,<bytes=%rdx
cmp $0,%rdx
# comment:fp stack unchanged by jump
# qhasm: goto done if !unsigned>
jbe ._done
# comment:fp stack unchanged by jump
# qhasm: goto start
jmp ._start
# qhasm: enter ECRYPT_encrypt_bytes
.text
.p2align 5
.globl _ECRYPT_encrypt_bytes
.globl ECRYPT_encrypt_bytes
_ECRYPT_encrypt_bytes:
ECRYPT_encrypt_bytes:
mov %rsp,%r11
and $31,%r11
add $352,%r11
sub %r11,%rsp
# qhasm: x = arg1
# asm 1: mov <arg1=int64#1,>x=int64#5
# asm 2: mov <arg1=%rdi,>x=%r8
mov %rdi,%r8
# qhasm: m = arg2
# asm 1: mov <arg2=int64#2,>m=int64#2
# asm 2: mov <arg2=%rsi,>m=%rsi
mov %rsi,%rsi
# qhasm: out = arg3
# asm 1: mov <arg3=int64#3,>out=int64#1
# asm 2: mov <arg3=%rdx,>out=%rdi
mov %rdx,%rdi
# qhasm: bytes = arg4
# asm 1: mov <arg4=int64#4,>bytes=int64#3
# asm 2: mov <arg4=%rcx,>bytes=%rdx
mov %rcx,%rdx
# qhasm: unsigned>? bytes - 0
# asm 1: cmp $0,<bytes=int64#3
# asm 2: cmp $0,<bytes=%rdx
cmp $0,%rdx
# comment:fp stack unchanged by jump
# qhasm: goto done if !unsigned>
jbe ._done
# comment:fp stack unchanged by fallthrough
# qhasm: start:
._start:
# qhasm: r11_stack = r11
# asm 1: movq <r11=int64#9,>r11_stack=stack64#1
# asm 2: movq <r11=%r11,>r11_stack=0(%rsp)
movq %r11,0(%rsp)
# qhasm: r12_stack = r12
# asm 1: movq <r12=int64#10,>r12_stack=stack64#2
# asm 2: movq <r12=%r12,>r12_stack=8(%rsp)
movq %r12,8(%rsp)
# qhasm: r13_stack = r13
# asm 1: movq <r13=int64#11,>r13_stack=stack64#3
# asm 2: movq <r13=%r13,>r13_stack=16(%rsp)
movq %r13,16(%rsp)
# qhasm: r14_stack = r14
# asm 1: movq <r14=int64#12,>r14_stack=stack64#4
# asm 2: movq <r14=%r14,>r14_stack=24(%rsp)
movq %r14,24(%rsp)
# qhasm: r15_stack = r15
# asm 1: movq <r15=int64#13,>r15_stack=stack64#5
# asm 2: movq <r15=%r15,>r15_stack=32(%rsp)
movq %r15,32(%rsp)
# qhasm: rbx_stack = rbx
# asm 1: movq <rbx=int64#14,>rbx_stack=stack64#6
# asm 2: movq <rbx=%rbx,>rbx_stack=40(%rsp)
movq %rbx,40(%rsp)
# qhasm: rbp_stack = rbp
# asm 1: movq <rbp=int64#15,>rbp_stack=stack64#7
# asm 2: movq <rbp=%rbp,>rbp_stack=48(%rsp)
movq %rbp,48(%rsp)
# qhasm: in0 = *(uint64 *) (x + 0)
# asm 1: movq 0(<x=int64#5),>in0=int64#4
# asm 2: movq 0(<x=%r8),>in0=%rcx
movq 0(%r8),%rcx
# qhasm: in2 = *(uint64 *) (x + 8)
# asm 1: movq 8(<x=int64#5),>in2=int64#6
# asm 2: movq 8(<x=%r8),>in2=%r9
movq 8(%r8),%r9
# qhasm: in4 = *(uint64 *) (x + 16)
# asm 1: movq 16(<x=int64#5),>in4=int64#7
# asm 2: movq 16(<x=%r8),>in4=%rax
movq 16(%r8),%rax
# qhasm: in6 = *(uint64 *) (x + 24)
# asm 1: movq 24(<x=int64#5),>in6=int64#8
# asm 2: movq 24(<x=%r8),>in6=%r10
movq 24(%r8),%r10
# qhasm: in8 = *(uint64 *) (x + 32)
# asm 1: movq 32(<x=int64#5),>in8=int64#9
# asm 2: movq 32(<x=%r8),>in8=%r11
movq 32(%r8),%r11
# qhasm: in10 = *(uint64 *) (x + 40)
# asm 1: movq 40(<x=int64#5),>in10=int64#10
# asm 2: movq 40(<x=%r8),>in10=%r12
movq 40(%r8),%r12
# qhasm: in12 = *(uint64 *) (x + 48)
# asm 1: movq 48(<x=int64#5),>in12=int64#11
# asm 2: movq 48(<x=%r8),>in12=%r13
movq 48(%r8),%r13
# qhasm: in14 = *(uint64 *) (x + 56)
# asm 1: movq 56(<x=int64#5),>in14=int64#12
# asm 2: movq 56(<x=%r8),>in14=%r14
movq 56(%r8),%r14
# qhasm: j0 = in0
# asm 1: movq <in0=int64#4,>j0=stack64#8
# asm 2: movq <in0=%rcx,>j0=56(%rsp)
movq %rcx,56(%rsp)
# qhasm: j2 = in2
# asm 1: movq <in2=int64#6,>j2=stack64#9
# asm 2: movq <in2=%r9,>j2=64(%rsp)
movq %r9,64(%rsp)
# qhasm: j4 = in4
# asm 1: movq <in4=int64#7,>j4=stack64#10
# asm 2: movq <in4=%rax,>j4=72(%rsp)
movq %rax,72(%rsp)
# qhasm: j6 = in6
# asm 1: movq <in6=int64#8,>j6=stack64#11
# asm 2: movq <in6=%r10,>j6=80(%rsp)
movq %r10,80(%rsp)
# qhasm: j8 = in8
# asm 1: movq <in8=int64#9,>j8=stack64#12
# asm 2: movq <in8=%r11,>j8=88(%rsp)
movq %r11,88(%rsp)
# qhasm: j10 = in10
# asm 1: movq <in10=int64#10,>j10=stack64#13
# asm 2: movq <in10=%r12,>j10=96(%rsp)
movq %r12,96(%rsp)
# qhasm: j12 = in12
# asm 1: movq <in12=int64#11,>j12=stack64#14
# asm 2: movq <in12=%r13,>j12=104(%rsp)
movq %r13,104(%rsp)
# qhasm: j14 = in14
# asm 1: movq <in14=int64#12,>j14=stack64#15
# asm 2: movq <in14=%r14,>j14=112(%rsp)
movq %r14,112(%rsp)
# qhasm: x_backup = x
# asm 1: movq <x=int64#5,>x_backup=stack64#16
# asm 2: movq <x=%r8,>x_backup=120(%rsp)
movq %r8,120(%rsp)
# qhasm: bytesatleast1:
._bytesatleast1:
# qhasm: unsigned<? bytes - 64
# asm 1: cmp $64,<bytes=int64#3
# asm 2: cmp $64,<bytes=%rdx
cmp $64,%rdx
# comment:fp stack unchanged by jump
# qhasm: goto nocopy if !unsigned<
jae ._nocopy
# qhasm: ctarget = out
# asm 1: mov <out=int64#1,>ctarget=int64#5
# asm 2: mov <out=%rdi,>ctarget=%r8
mov %rdi,%r8
# qhasm: out = &tmp
# asm 1: leaq <tmp=stack512#1,>out=int64#1
# asm 2: leaq <tmp=288(%rsp),>out=%rdi
leaq 288(%rsp),%rdi
# qhasm: i = bytes
# asm 1: mov <bytes=int64#3,>i=int64#4
# asm 2: mov <bytes=%rdx,>i=%rcx
mov %rdx,%rcx
# qhasm: while (i) { *out++ = *m++; --i }
rep movsb
# qhasm: out = &tmp
# asm 1: leaq <tmp=stack512#1,>out=int64#1
# asm 2: leaq <tmp=288(%rsp),>out=%rdi
leaq 288(%rsp),%rdi
# qhasm: m = &tmp
# asm 1: leaq <tmp=stack512#1,>m=int64#2
# asm 2: leaq <tmp=288(%rsp),>m=%rsi
leaq 288(%rsp),%rsi
# comment:fp stack unchanged by fallthrough
# qhasm: nocopy:
._nocopy:
# qhasm: out_backup = out
# asm 1: movq <out=int64#1,>out_backup=stack64#17
# asm 2: movq <out=%rdi,>out_backup=128(%rsp)
movq %rdi,128(%rsp)
# qhasm: m_backup = m
# asm 1: movq <m=int64#2,>m_backup=stack64#18
# asm 2: movq <m=%rsi,>m_backup=136(%rsp)
movq %rsi,136(%rsp)
# qhasm: bytes_backup = bytes
# asm 1: movq <bytes=int64#3,>bytes_backup=stack64#19
# asm 2: movq <bytes=%rdx,>bytes_backup=144(%rsp)
movq %rdx,144(%rsp)
# qhasm: in0 = j0
# asm 1: movq <j0=stack64#8,>in0=int64#1
# asm 2: movq <j0=56(%rsp),>in0=%rdi
movq 56(%rsp),%rdi
# qhasm: in2 = j2
# asm 1: movq <j2=stack64#9,>in2=int64#2
# asm 2: movq <j2=64(%rsp),>in2=%rsi
movq 64(%rsp),%rsi
# qhasm: in4 = j4
# asm 1: movq <j4=stack64#10,>in4=int64#3
# asm 2: movq <j4=72(%rsp),>in4=%rdx
movq 72(%rsp),%rdx
# qhasm: in6 = j6
# asm 1: movq <j6=stack64#11,>in6=int64#4
# asm 2: movq <j6=80(%rsp),>in6=%rcx
movq 80(%rsp),%rcx
# qhasm: in8 = j8
# asm 1: movq <j8=stack64#12,>in8=int64#6
# asm 2: movq <j8=88(%rsp),>in8=%r9
movq 88(%rsp),%r9
# qhasm: in10 = j10
# asm 1: movq <j10=stack64#13,>in10=int64#7
# asm 2: movq <j10=96(%rsp),>in10=%rax
movq 96(%rsp),%rax
# qhasm: in12 = j12
# asm 1: movq <j12=stack64#14,>in12=int64#8
# asm 2: movq <j12=104(%rsp),>in12=%r10
movq 104(%rsp),%r10
# qhasm: in14 = j14
# asm 1: movq <j14=stack64#15,>in14=int64#9
# asm 2: movq <j14=112(%rsp),>in14=%r11
movq 112(%rsp),%r11
# qhasm: x0 = in0
# asm 1: movq <in0=int64#1,>x0=stack64#20
# asm 2: movq <in0=%rdi,>x0=152(%rsp)
movq %rdi,152(%rsp)
# qhasm: x2 = in2
# asm 1: movq <in2=int64#2,>x2=stack64#21
# asm 2: movq <in2=%rsi,>x2=160(%rsp)
movq %rsi,160(%rsp)
# qhasm: x4 = in4
# asm 1: movq <in4=int64#3,>x4=stack64#22
# asm 2: movq <in4=%rdx,>x4=168(%rsp)
movq %rdx,168(%rsp)
# qhasm: x6 = in6
# asm 1: movq <in6=int64#4,>x6=stack64#23
# asm 2: movq <in6=%rcx,>x6=176(%rsp)
movq %rcx,176(%rsp)
# qhasm: x8 = in8
# asm 1: movq <in8=int64#6,>x8=stack64#24
# asm 2: movq <in8=%r9,>x8=184(%rsp)
movq %r9,184(%rsp)
# qhasm: x10 = in10
# asm 1: movq <in10=int64#7,>x10=stack64#25
# asm 2: movq <in10=%rax,>x10=192(%rsp)
movq %rax,192(%rsp)
# qhasm: x12 = in12
# asm 1: movq <in12=int64#8,>x12=stack64#26
# asm 2: movq <in12=%r10,>x12=200(%rsp)
movq %r10,200(%rsp)
# qhasm: x14 = in14
# asm 1: movq <in14=int64#9,>x14=stack64#27
# asm 2: movq <in14=%r11,>x14=208(%rsp)
movq %r11,208(%rsp)
# qhasm: (uint64) in0 >>= 32
# asm 1: shr $32,<in0=int64#1
# asm 2: shr $32,<in0=%rdi
shr $32,%rdi
# qhasm: (uint64) in2 >>= 32
# asm 1: shr $32,<in2=int64#2
# asm 2: shr $32,<in2=%rsi
shr $32,%rsi
# qhasm: (uint64) in4 >>= 32
# asm 1: shr $32,<in4=int64#3
# asm 2: shr $32,<in4=%rdx
shr $32,%rdx
# qhasm: (uint64) in6 >>= 32
# asm 1: shr $32,<in6=int64#4
# asm 2: shr $32,<in6=%rcx
shr $32,%rcx
# qhasm: (uint64) in8 >>= 32
# asm 1: shr $32,<in8=int64#6
# asm 2: shr $32,<in8=%r9
shr $32,%r9
# qhasm: (uint64) in10 >>= 32
# asm 1: shr $32,<in10=int64#7
# asm 2: shr $32,<in10=%rax
shr $32,%rax
# qhasm: (uint64) in12 >>= 32
# asm 1: shr $32,<in12=int64#8
# asm 2: shr $32,<in12=%r10
shr $32,%r10
# qhasm: (uint64) in14 >>= 32
# asm 1: shr $32,<in14=int64#9
# asm 2: shr $32,<in14=%r11
shr $32,%r11
# qhasm: x1 = in0
# asm 1: movq <in0=int64#1,>x1=stack64#28
# asm 2: movq <in0=%rdi,>x1=216(%rsp)
movq %rdi,216(%rsp)
# qhasm: x3 = in2
# asm 1: movq <in2=int64#2,>x3=stack64#29
# asm 2: movq <in2=%rsi,>x3=224(%rsp)
movq %rsi,224(%rsp)
# qhasm: x5 = in4
# asm 1: movq <in4=int64#3,>x5=stack64#30
# asm 2: movq <in4=%rdx,>x5=232(%rsp)
movq %rdx,232(%rsp)
# qhasm: x7 = in6
# asm 1: movq <in6=int64#4,>x7=stack64#31
# asm 2: movq <in6=%rcx,>x7=240(%rsp)
movq %rcx,240(%rsp)
# qhasm: x9 = in8
# asm 1: movq <in8=int64#6,>x9=stack64#32
# asm 2: movq <in8=%r9,>x9=248(%rsp)
movq %r9,248(%rsp)
# qhasm: x11 = in10
# asm 1: movq <in10=int64#7,>x11=stack64#33
# asm 2: movq <in10=%rax,>x11=256(%rsp)
movq %rax,256(%rsp)
# qhasm: x13 = in12
# asm 1: movq <in12=int64#8,>x13=stack64#34
# asm 2: movq <in12=%r10,>x13=264(%rsp)
movq %r10,264(%rsp)
# qhasm: x15 = in14
# asm 1: movq <in14=int64#9,>x15=stack64#35
# asm 2: movq <in14=%r11,>x15=272(%rsp)
movq %r11,272(%rsp)
# qhasm: i = 8
# asm 1: mov $8,>i=int64#4
# asm 2: mov $8,>i=%rcx
mov $8,%rcx
# qhasm: mainloop:
._mainloop:
# qhasm: a = x12
# asm 1: movq <x12=stack64#26,>a=int64#1
# asm 2: movq <x12=200(%rsp),>a=%rdi
movq 200(%rsp),%rdi
# qhasm: b = x0
# asm 1: movq <x0=stack64#20,>b=int64#2
# asm 2: movq <x0=152(%rsp),>b=%rsi
movq 152(%rsp),%rsi
# qhasm: c = x4
# asm 1: movq <x4=stack64#22,>c=int64#3
# asm 2: movq <x4=168(%rsp),>c=%rdx
movq 168(%rsp),%rdx
# qhasm: e = a + b
# asm 1: lea (<a=int64#1,<b=int64#2),>e=int64#6
# asm 2: lea (<a=%rdi,<b=%rsi),>e=%r9
lea (%rdi,%rsi),%r9
# qhasm: (uint32) e <<<= 7
# asm 1: rol $7,<e=int64#6d
# asm 2: rol $7,<e=%r9d
rol $7,%r9d
# qhasm: c ^= e
# asm 1: xor <e=int64#6,<c=int64#3
# asm 2: xor <e=%r9,<c=%rdx
xor %r9,%rdx
# qhasm: x4 = c
# asm 1: movq <c=int64#3,>x4=stack64#22
# asm 2: movq <c=%rdx,>x4=168(%rsp)
movq %rdx,168(%rsp)
# qhasm: d = x8
# asm 1: movq <x8=stack64#24,>d=int64#6
# asm 2: movq <x8=184(%rsp),>d=%r9
movq 184(%rsp),%r9
# qhasm: e = b + c
# asm 1: lea (<b=int64#2,<c=int64#3),>e=int64#7
# asm 2: lea (<b=%rsi,<c=%rdx),>e=%rax
lea (%rsi,%rdx),%rax
# qhasm: (uint32) e <<<= 9
# asm 1: rol $9,<e=int64#7d
# asm 2: rol $9,<e=%eax
rol $9,%eax
# qhasm: d ^= e
# asm 1: xor <e=int64#7,<d=int64#6
# asm 2: xor <e=%rax,<d=%r9
xor %rax,%r9
# qhasm: x8 = d
# asm 1: movq <d=int64#6,>x8=stack64#24
# asm 2: movq <d=%r9,>x8=184(%rsp)
movq %r9,184(%rsp)
# qhasm: c += d
# asm 1: add <d=int64#6,<c=int64#3
# asm 2: add <d=%r9,<c=%rdx
add %r9,%rdx
# qhasm: (uint32) c <<<= 13
# asm 1: rol $13,<c=int64#3d
# asm 2: rol $13,<c=%edx
rol $13,%edx
# qhasm: a ^= c
# asm 1: xor <c=int64#3,<a=int64#1
# asm 2: xor <c=%rdx,<a=%rdi
xor %rdx,%rdi
# qhasm: x12 = a
# asm 1: movq <a=int64#1,>x12=stack64#26
# asm 2: movq <a=%rdi,>x12=200(%rsp)
movq %rdi,200(%rsp)
# qhasm: a += d
# asm 1: add <d=int64#6,<a=int64#1
# asm 2: add <d=%r9,<a=%rdi
add %r9,%rdi
# qhasm: (uint32) a <<<= 18
# asm 1: rol $18,<a=int64#1d
# asm 2: rol $18,<a=%edi
rol $18,%edi
# qhasm: b ^= a
# asm 1: xor <a=int64#1,<b=int64#2
# asm 2: xor <a=%rdi,<b=%rsi
xor %rdi,%rsi
# qhasm: x0 = b
# asm 1: movq <b=int64#2,>x0=stack64#20
# asm 2: movq <b=%rsi,>x0=152(%rsp)
movq %rsi,152(%rsp)
# qhasm: r = x1
# asm 1: movq <x1=stack64#28,>r=int64#1
# asm 2: movq <x1=216(%rsp),>r=%rdi
movq 216(%rsp),%rdi
# qhasm: s = x5
# asm 1: movq <x5=stack64#30,>s=int64#2
# asm 2: movq <x5=232(%rsp),>s=%rsi
movq 232(%rsp),%rsi
# qhasm: t = x9
# asm 1: movq <x9=stack64#32,>t=int64#3
# asm 2: movq <x9=248(%rsp),>t=%rdx
movq 248(%rsp),%rdx
# qhasm: v = r + s
# asm 1: lea (<r=int64#1,<s=int64#2),>v=int64#6
# asm 2: lea (<r=%rdi,<s=%rsi),>v=%r9
lea (%rdi,%rsi),%r9
# qhasm: (uint32) v <<<= 7
# asm 1: rol $7,<v=int64#6d
# asm 2: rol $7,<v=%r9d
rol $7,%r9d
# qhasm: t ^= v
# asm 1: xor <v=int64#6,<t=int64#3
# asm 2: xor <v=%r9,<t=%rdx
xor %r9,%rdx
# qhasm: x9 = t
# asm 1: movq <t=int64#3,>x9=stack64#32
# asm 2: movq <t=%rdx,>x9=248(%rsp)
movq %rdx,248(%rsp)
# qhasm: u = x13
# asm 1: movq <x13=stack64#34,>u=int64#6
# asm 2: movq <x13=264(%rsp),>u=%r9
movq 264(%rsp),%r9
# qhasm: v = s + t
# asm 1: lea (<s=int64#2,<t=int64#3),>v=int64#7
# asm 2: lea (<s=%rsi,<t=%rdx),>v=%rax
lea (%rsi,%rdx),%rax
# qhasm: (uint32) v <<<= 9
# asm 1: rol $9,<v=int64#7d
# asm 2: rol $9,<v=%eax
rol $9,%eax
# qhasm: u ^= v
# asm 1: xor <v=int64#7,<u=int64#6
# asm 2: xor <v=%rax,<u=%r9
xor %rax,%r9
# qhasm: x13 = u
# asm 1: movq <u=int64#6,>x13=stack64#34
# asm 2: movq <u=%r9,>x13=264(%rsp)
movq %r9,264(%rsp)
# qhasm: t += u
# asm 1: add <u=int64#6,<t=int64#3
# asm 2: add <u=%r9,<t=%rdx
add %r9,%rdx
# qhasm: (uint32) t <<<= 13
# asm 1: rol $13,<t=int64#3d
# asm 2: rol $13,<t=%edx
rol $13,%edx
# qhasm: r ^= t
# asm 1: xor <t=int64#3,<r=int64#1
# asm 2: xor <t=%rdx,<r=%rdi
xor %rdx,%rdi
# qhasm: x1 = r
# asm 1: movq <r=int64#1,>x1=stack64#28
# asm 2: movq <r=%rdi,>x1=216(%rsp)
movq %rdi,216(%rsp)
# qhasm: r += u
# asm 1: add <u=int64#6,<r=int64#1
# asm 2: add <u=%r9,<r=%rdi
add %r9,%rdi
# qhasm: (uint32) r <<<= 18
# asm 1: rol $18,<r=int64#1d
# asm 2: rol $18,<r=%edi
rol $18,%edi
# qhasm: s ^= r
# asm 1: xor <r=int64#1,<s=int64#2
# asm 2: xor <r=%rdi,<s=%rsi
xor %rdi,%rsi
# qhasm: x5 = s
# asm 1: movq <s=int64#2,>x5=stack64#30
# asm 2: movq <s=%rsi,>x5=232(%rsp)
movq %rsi,232(%rsp)
# qhasm: A = x6
# asm 1: movq <x6=stack64#23,>A=int64#1
# asm 2: movq <x6=176(%rsp),>A=%rdi
movq 176(%rsp),%rdi
# qhasm: B = x10
# asm 1: movq <x10=stack64#25,>B=int64#2
# asm 2: movq <x10=192(%rsp),>B=%rsi
movq 192(%rsp),%rsi
# qhasm: C = x14
# asm 1: movq <x14=stack64#27,>C=int64#3
# asm 2: movq <x14=208(%rsp),>C=%rdx
movq 208(%rsp),%rdx
# qhasm: E = A + B
# asm 1: lea (<A=int64#1,<B=int64#2),>E=int64#6
# asm 2: lea (<A=%rdi,<B=%rsi),>E=%r9
lea (%rdi,%rsi),%r9
# qhasm: (uint32) E <<<= 7
# asm 1: rol $7,<E=int64#6d
# asm 2: rol $7,<E=%r9d
rol $7,%r9d
# qhasm: C ^= E
# asm 1: xor <E=int64#6,<C=int64#3
# asm 2: xor <E=%r9,<C=%rdx
xor %r9,%rdx
# qhasm: x14 = C
# asm 1: movq <C=int64#3,>x14=stack64#27
# asm 2: movq <C=%rdx,>x14=208(%rsp)
movq %rdx,208(%rsp)
# qhasm: D = x2
# asm 1: movq <x2=stack64#21,>D=int64#6
# asm 2: movq <x2=160(%rsp),>D=%r9
movq 160(%rsp),%r9
# qhasm: E = B + C
# asm 1: lea (<B=int64#2,<C=int64#3),>E=int64#7
# asm 2: lea (<B=%rsi,<C=%rdx),>E=%rax
lea (%rsi,%rdx),%rax
# qhasm: (uint32) E <<<= 9
# asm 1: rol $9,<E=int64#7d
# asm 2: rol $9,<E=%eax
rol $9,%eax
# qhasm: D ^= E
# asm 1: xor <E=int64#7,<D=int64#6
# asm 2: xor <E=%rax,<D=%r9
xor %rax,%r9
# qhasm: x2 = D
# asm 1: movq <D=int64#6,>x2=stack64#21
# asm 2: movq <D=%r9,>x2=160(%rsp)
movq %r9,160(%rsp)
# qhasm: C += D
# asm 1: add <D=int64#6,<C=int64#3
# asm 2: add <D=%r9,<C=%rdx
add %r9,%rdx
# qhasm: (uint32) C <<<= 13
# asm 1: rol $13,<C=int64#3d
# asm 2: rol $13,<C=%edx
rol $13,%edx
# qhasm: A ^= C
# asm 1: xor <C=int64#3,<A=int64#1
# asm 2: xor <C=%rdx,<A=%rdi
xor %rdx,%rdi
# qhasm: x6 = A
# asm 1: movq <A=int64#1,>x6=stack64#23
# asm 2: movq <A=%rdi,>x6=176(%rsp)
movq %rdi,176(%rsp)
# qhasm: A += D
# asm 1: add <D=int64#6,<A=int64#1
# asm 2: add <D=%r9,<A=%rdi
add %r9,%rdi
# qhasm: (uint32) A <<<= 18
# asm 1: rol $18,<A=int64#1d
# asm 2: rol $18,<A=%edi
rol $18,%edi
# qhasm: B ^= A
# asm 1: xor <A=int64#1,<B=int64#2
# asm 2: xor <A=%rdi,<B=%rsi
xor %rdi,%rsi
# qhasm: x10 = B
# asm 1: movq <B=int64#2,>x10=stack64#25
# asm 2: movq <B=%rsi,>x10=192(%rsp)
movq %rsi,192(%rsp)
# qhasm: R = x11
# asm 1: movq <x11=stack64#33,>R=int64#1
# asm 2: movq <x11=256(%rsp),>R=%rdi
movq 256(%rsp),%rdi
# qhasm: S = x15
# asm 1: movq <x15=stack64#35,>S=int64#2
# asm 2: movq <x15=272(%rsp),>S=%rsi
movq 272(%rsp),%rsi
# qhasm: T = x3
# asm 1: movq <x3=stack64#29,>T=int64#3
# asm 2: movq <x3=224(%rsp),>T=%rdx
movq 224(%rsp),%rdx
# qhasm: V = R + S
# asm 1: lea (<R=int64#1,<S=int64#2),>V=int64#6
# asm 2: lea (<R=%rdi,<S=%rsi),>V=%r9
lea (%rdi,%rsi),%r9
# qhasm: (uint32) V <<<= 7
# asm 1: rol $7,<V=int64#6d
# asm 2: rol $7,<V=%r9d
rol $7,%r9d
# qhasm: T ^= V
# asm 1: xor <V=int64#6,<T=int64#3
# asm 2: xor <V=%r9,<T=%rdx
xor %r9,%rdx
# qhasm: x3 = T
# asm 1: movq <T=int64#3,>x3=stack64#29
# asm 2: movq <T=%rdx,>x3=224(%rsp)
movq %rdx,224(%rsp)
# qhasm: U = x7
# asm 1: movq <x7=stack64#31,>U=int64#6
# asm 2: movq <x7=240(%rsp),>U=%r9
movq 240(%rsp),%r9
# qhasm: V = S + T
# asm 1: lea (<S=int64#2,<T=int64#3),>V=int64#7
# asm 2: lea (<S=%rsi,<T=%rdx),>V=%rax
lea (%rsi,%rdx),%rax
# qhasm: (uint32) V <<<= 9
# asm 1: rol $9,<V=int64#7d
# asm 2: rol $9,<V=%eax
rol $9,%eax
# qhasm: U ^= V
# asm 1: xor <V=int64#7,<U=int64#6
# asm 2: xor <V=%rax,<U=%r9
xor %rax,%r9
# qhasm: x7 = U
# asm 1: movq <U=int64#6,>x7=stack64#31
# asm 2: movq <U=%r9,>x7=240(%rsp)
movq %r9,240(%rsp)
# qhasm: T += U
# asm 1: add <U=int64#6,<T=int64#3
# asm 2: add <U=%r9,<T=%rdx
add %r9,%rdx
# qhasm: (uint32) T <<<= 13
# asm 1: rol $13,<T=int64#3d
# asm 2: rol $13,<T=%edx
rol $13,%edx
# qhasm: R ^= T
# asm 1: xor <T=int64#3,<R=int64#1
# asm 2: xor <T=%rdx,<R=%rdi
xor %rdx,%rdi
# qhasm: x11 = R
# asm 1: movq <R=int64#1,>x11=stack64#33
# asm 2: movq <R=%rdi,>x11=256(%rsp)
movq %rdi,256(%rsp)
# qhasm: R += U
# asm 1: add <U=int64#6,<R=int64#1
# asm 2: add <U=%r9,<R=%rdi
add %r9,%rdi
# qhasm: (uint32) R <<<= 18
# asm 1: rol $18,<R=int64#1d
# asm 2: rol $18,<R=%edi
rol $18,%edi
# qhasm: S ^= R
# asm 1: xor <R=int64#1,<S=int64#2
# asm 2: xor <R=%rdi,<S=%rsi
xor %rdi,%rsi
# qhasm: x15 = S
# asm 1: movq <S=int64#2,>x15=stack64#35
# asm 2: movq <S=%rsi,>x15=272(%rsp)
movq %rsi,272(%rsp)
# qhasm: a = x3
# asm 1: movq <x3=stack64#29,>a=int64#7
# asm 2: movq <x3=224(%rsp),>a=%rax
movq 224(%rsp),%rax
# qhasm: b = x0
# asm 1: movq <x0=stack64#20,>b=int64#1
# asm 2: movq <x0=152(%rsp),>b=%rdi
movq 152(%rsp),%rdi
# qhasm: c = x1
# asm 1: movq <x1=stack64#28,>c=int64#2
# asm 2: movq <x1=216(%rsp),>c=%rsi
movq 216(%rsp),%rsi
# qhasm: e = a + b
# asm 1: lea (<a=int64#7,<b=int64#1),>e=int64#3
# asm 2: lea (<a=%rax,<b=%rdi),>e=%rdx
lea (%rax,%rdi),%rdx
# qhasm: (uint32) e <<<= 7
# asm 1: rol $7,<e=int64#3d
# asm 2: rol $7,<e=%edx
rol $7,%edx
# qhasm: c ^= e
# asm 1: xor <e=int64#3,<c=int64#2
# asm 2: xor <e=%rdx,<c=%rsi
xor %rdx,%rsi
# qhasm: x1 = c
# asm 1: movq <c=int64#2,>x1=stack64#28
# asm 2: movq <c=%rsi,>x1=216(%rsp)
movq %rsi,216(%rsp)
# qhasm: d = x2
# asm 1: movq <x2=stack64#21,>d=int64#3
# asm 2: movq <x2=160(%rsp),>d=%rdx
movq 160(%rsp),%rdx
# qhasm: e = b + c
# asm 1: lea (<b=int64#1,<c=int64#2),>e=int64#6
# asm 2: lea (<b=%rdi,<c=%rsi),>e=%r9
lea (%rdi,%rsi),%r9
# qhasm: (uint32) e <<<= 9
# asm 1: rol $9,<e=int64#6d
# asm 2: rol $9,<e=%r9d
rol $9,%r9d
# qhasm: d ^= e
# asm 1: xor <e=int64#6,<d=int64#3
# asm 2: xor <e=%r9,<d=%rdx
xor %r9,%rdx
# qhasm: x2 = d
# asm 1: movq <d=int64#3,>x2=stack64#21
# asm 2: movq <d=%rdx,>x2=160(%rsp)
movq %rdx,160(%rsp)
# qhasm: c += d
# asm 1: add <d=int64#3,<c=int64#2
# asm 2: add <d=%rdx,<c=%rsi
add %rdx,%rsi
# qhasm: (uint32) c <<<= 13
# asm 1: rol $13,<c=int64#2d
# asm 2: rol $13,<c=%esi
rol $13,%esi
# qhasm: a ^= c
# asm 1: xor <c=int64#2,<a=int64#7
# asm 2: xor <c=%rsi,<a=%rax
xor %rsi,%rax
# qhasm: x3 = a
# asm 1: movq <a=int64#7,>x3=stack64#29
# asm 2: movq <a=%rax,>x3=224(%rsp)
movq %rax,224(%rsp)
# qhasm: a += d
# asm 1: add <d=int64#3,<a=int64#7
# asm 2: add <d=%rdx,<a=%rax
add %rdx,%rax
# qhasm: (uint32) a <<<= 18
# asm 1: rol $18,<a=int64#7d
# asm 2: rol $18,<a=%eax
rol $18,%eax
# qhasm: b ^= a
# asm 1: xor <a=int64#7,<b=int64#1
# asm 2: xor <a=%rax,<b=%rdi
xor %rax,%rdi
# qhasm: x0 = b
# asm 1: movq <b=int64#1,>x0=stack64#20
# asm 2: movq <b=%rdi,>x0=152(%rsp)
movq %rdi,152(%rsp)
# qhasm: r = x4
# asm 1: movq <x4=stack64#22,>r=int64#1
# asm 2: movq <x4=168(%rsp),>r=%rdi
movq 168(%rsp),%rdi
# qhasm: s = x5
# asm 1: movq <x5=stack64#30,>s=int64#2
# asm 2: movq <x5=232(%rsp),>s=%rsi
movq 232(%rsp),%rsi
# qhasm: t = x6
# asm 1: movq <x6=stack64#23,>t=int64#3
# asm 2: movq <x6=176(%rsp),>t=%rdx
movq 176(%rsp),%rdx
# qhasm: v = r + s
# asm 1: lea (<r=int64#1,<s=int64#2),>v=int64#6
# asm 2: lea (<r=%rdi,<s=%rsi),>v=%r9
lea (%rdi,%rsi),%r9
# qhasm: (uint32) v <<<= 7
# asm 1: rol $7,<v=int64#6d
# asm 2: rol $7,<v=%r9d
rol $7,%r9d
# qhasm: t ^= v
# asm 1: xor <v=int64#6,<t=int64#3
# asm 2: xor <v=%r9,<t=%rdx
xor %r9,%rdx
# qhasm: x6 = t
# asm 1: movq <t=int64#3,>x6=stack64#23
# asm 2: movq <t=%rdx,>x6=176(%rsp)
movq %rdx,176(%rsp)
# qhasm: u = x7
# asm 1: movq <x7=stack64#31,>u=int64#6
# asm 2: movq <x7=240(%rsp),>u=%r9
movq 240(%rsp),%r9
# qhasm: v = s + t
# asm 1: lea (<s=int64#2,<t=int64#3),>v=int64#7
# asm 2: lea (<s=%rsi,<t=%rdx),>v=%rax
lea (%rsi,%rdx),%rax
# qhasm: (uint32) v <<<= 9
# asm 1: rol $9,<v=int64#7d
# asm 2: rol $9,<v=%eax
rol $9,%eax
# qhasm: u ^= v
# asm 1: xor <v=int64#7,<u=int64#6
# asm 2: xor <v=%rax,<u=%r9
xor %rax,%r9
# qhasm: x7 = u
# asm 1: movq <u=int64#6,>x7=stack64#31
# asm 2: movq <u=%r9,>x7=240(%rsp)
movq %r9,240(%rsp)
# qhasm: t += u
# asm 1: add <u=int64#6,<t=int64#3
# asm 2: add <u=%r9,<t=%rdx
add %r9,%rdx
# qhasm: (uint32) t <<<= 13
# asm 1: rol $13,<t=int64#3d
# asm 2: rol $13,<t=%edx
rol $13,%edx
# qhasm: r ^= t
# asm 1: xor <t=int64#3,<r=int64#1
# asm 2: xor <t=%rdx,<r=%rdi
xor %rdx,%rdi
# qhasm: x4 = r
# asm 1: movq <r=int64#1,>x4=stack64#22
# asm 2: movq <r=%rdi,>x4=168(%rsp)
movq %rdi,168(%rsp)
# qhasm: r += u
# asm 1: add <u=int64#6,<r=int64#1
# asm 2: add <u=%r9,<r=%rdi
add %r9,%rdi
# qhasm: (uint32) r <<<= 18
# asm 1: rol $18,<r=int64#1d
# asm 2: rol $18,<r=%edi
rol $18,%edi
# qhasm: s ^= r
# asm 1: xor <r=int64#1,<s=int64#2
# asm 2: xor <r=%rdi,<s=%rsi
xor %rdi,%rsi
# qhasm: x5 = s
# asm 1: movq <s=int64#2,>x5=stack64#30
# asm 2: movq <s=%rsi,>x5=232(%rsp)
movq %rsi,232(%rsp)
# qhasm: A = x9
# asm 1: movq <x9=stack64#32,>A=int64#1
# asm 2: movq <x9=248(%rsp),>A=%rdi
movq 248(%rsp),%rdi
# qhasm: B = x10
# asm 1: movq <x10=stack64#25,>B=int64#2
# asm 2: movq <x10=192(%rsp),>B=%rsi
movq 192(%rsp),%rsi
# qhasm: C = x11
# asm 1: movq <x11=stack64#33,>C=int64#3
# asm 2: movq <x11=256(%rsp),>C=%rdx
movq 256(%rsp),%rdx
# qhasm: E = A + B
# asm 1: lea (<A=int64#1,<B=int64#2),>E=int64#6
# asm 2: lea (<A=%rdi,<B=%rsi),>E=%r9
lea (%rdi,%rsi),%r9
# qhasm: (uint32) E <<<= 7
# asm 1: rol $7,<E=int64#6d
# asm 2: rol $7,<E=%r9d
rol $7,%r9d
# qhasm: C ^= E
# asm 1: xor <E=int64#6,<C=int64#3
# asm 2: xor <E=%r9,<C=%rdx
xor %r9,%rdx
# qhasm: x11 = C
# asm 1: movq <C=int64#3,>x11=stack64#33
# asm 2: movq <C=%rdx,>x11=256(%rsp)
movq %rdx,256(%rsp)
# qhasm: D = x8
# asm 1: movq <x8=stack64#24,>D=int64#6
# asm 2: movq <x8=184(%rsp),>D=%r9
movq 184(%rsp),%r9
# qhasm: E = B + C
# asm 1: lea (<B=int64#2,<C=int64#3),>E=int64#7
# asm 2: lea (<B=%rsi,<C=%rdx),>E=%rax
lea (%rsi,%rdx),%rax
# qhasm: (uint32) E <<<= 9
# asm 1: rol $9,<E=int64#7d
# asm 2: rol $9,<E=%eax
rol $9,%eax
# qhasm: D ^= E
# asm 1: xor <E=int64#7,<D=int64#6
# asm 2: xor <E=%rax,<D=%r9
xor %rax,%r9
# qhasm: x8 = D
# asm 1: movq <D=int64#6,>x8=stack64#24
# asm 2: movq <D=%r9,>x8=184(%rsp)
movq %r9,184(%rsp)
# qhasm: C += D
# asm 1: add <D=int64#6,<C=int64#3
# asm 2: add <D=%r9,<C=%rdx
add %r9,%rdx
# qhasm: (uint32) C <<<= 13
# asm 1: rol $13,<C=int64#3d
# asm 2: rol $13,<C=%edx
rol $13,%edx
# qhasm: A ^= C
# asm 1: xor <C=int64#3,<A=int64#1
# asm 2: xor <C=%rdx,<A=%rdi
xor %rdx,%rdi
# qhasm: x9 = A
# asm 1: movq <A=int64#1,>x9=stack64#32
# asm 2: movq <A=%rdi,>x9=248(%rsp)
movq %rdi,248(%rsp)
# qhasm: A += D
# asm 1: add <D=int64#6,<A=int64#1
# asm 2: add <D=%r9,<A=%rdi
add %r9,%rdi
# qhasm: (uint32) A <<<= 18
# asm 1: rol $18,<A=int64#1d
# asm 2: rol $18,<A=%edi
rol $18,%edi
# qhasm: B ^= A
# asm 1: xor <A=int64#1,<B=int64#2
# asm 2: xor <A=%rdi,<B=%rsi
xor %rdi,%rsi
# qhasm: x10 = B
# asm 1: movq <B=int64#2,>x10=stack64#25
# asm 2: movq <B=%rsi,>x10=192(%rsp)
movq %rsi,192(%rsp)
# qhasm: R = x14
# asm 1: movq <x14=stack64#27,>R=int64#1
# asm 2: movq <x14=208(%rsp),>R=%rdi
movq 208(%rsp),%rdi
# qhasm: S = x15
# asm 1: movq <x15=stack64#35,>S=int64#2
# asm 2: movq <x15=272(%rsp),>S=%rsi
movq 272(%rsp),%rsi
# qhasm: T = x12
# asm 1: movq <x12=stack64#26,>T=int64#3
# asm 2: movq <x12=200(%rsp),>T=%rdx
movq 200(%rsp),%rdx
# qhasm: V = R + S
# asm 1: lea (<R=int64#1,<S=int64#2),>V=int64#6
# asm 2: lea (<R=%rdi,<S=%rsi),>V=%r9
lea (%rdi,%rsi),%r9
# qhasm: (uint32) V <<<= 7
# asm 1: rol $7,<V=int64#6d
# asm 2: rol $7,<V=%r9d
rol $7,%r9d
# qhasm: T ^= V
# asm 1: xor <V=int64#6,<T=int64#3
# asm 2: xor <V=%r9,<T=%rdx
xor %r9,%rdx
# qhasm: x12 = T
# asm 1: movq <T=int64#3,>x12=stack64#26
# asm 2: movq <T=%rdx,>x12=200(%rsp)
movq %rdx,200(%rsp)
# qhasm: U = x13
# asm 1: movq <x13=stack64#34,>U=int64#6
# asm 2: movq <x13=264(%rsp),>U=%r9
movq 264(%rsp),%r9
# qhasm: V = S + T
# asm 1: lea (<S=int64#2,<T=int64#3),>V=int64#7
# asm 2: lea (<S=%rsi,<T=%rdx),>V=%rax
lea (%rsi,%rdx),%rax
# qhasm: (uint32) V <<<= 9
# asm 1: rol $9,<V=int64#7d
# asm 2: rol $9,<V=%eax
rol $9,%eax
# qhasm: U ^= V
# asm 1: xor <V=int64#7,<U=int64#6
# asm 2: xor <V=%rax,<U=%r9
xor %rax,%r9
# qhasm: x13 = U
# asm 1: movq <U=int64#6,>x13=stack64#34
# asm 2: movq <U=%r9,>x13=264(%rsp)
movq %r9,264(%rsp)
# qhasm: T += U
# asm 1: add <U=int64#6,<T=int64#3
# asm 2: add <U=%r9,<T=%rdx
add %r9,%rdx
# qhasm: (uint32) T <<<= 13
# asm 1: rol $13,<T=int64#3d
# asm 2: rol $13,<T=%edx
rol $13,%edx
# qhasm: R ^= T
# asm 1: xor <T=int64#3,<R=int64#1
# asm 2: xor <T=%rdx,<R=%rdi
xor %rdx,%rdi
# qhasm: x14 = R
# asm 1: movq <R=int64#1,>x14=stack64#27
# asm 2: movq <R=%rdi,>x14=208(%rsp)
movq %rdi,208(%rsp)
# qhasm: R += U
# asm 1: add <U=int64#6,<R=int64#1
# asm 2: add <U=%r9,<R=%rdi
add %r9,%rdi
# qhasm: (uint32) R <<<= 18
# asm 1: rol $18,<R=int64#1d
# asm 2: rol $18,<R=%edi
rol $18,%edi
# qhasm: S ^= R
# asm 1: xor <R=int64#1,<S=int64#2
# asm 2: xor <R=%rdi,<S=%rsi
xor %rdi,%rsi
# qhasm: x15 = S
# asm 1: movq <S=int64#2,>x15=stack64#35
# asm 2: movq <S=%rsi,>x15=272(%rsp)
movq %rsi,272(%rsp)
# qhasm: unsigned>? i -= 2
# asm 1: sub $2,<i=int64#4
# asm 2: sub $2,<i=%rcx
sub $2,%rcx
# comment:fp stack unchanged by jump
# qhasm: goto mainloop if unsigned>
ja ._mainloop
# qhasm: out = out_backup
# asm 1: movq <out_backup=stack64#17,>out=int64#1
# asm 2: movq <out_backup=128(%rsp),>out=%rdi
movq 128(%rsp),%rdi
# qhasm: m = m_backup
# asm 1: movq <m_backup=stack64#18,>m=int64#2
# asm 2: movq <m_backup=136(%rsp),>m=%rsi
movq 136(%rsp),%rsi
# qhasm: in0 = j0
# asm 1: movq <j0=stack64#8,>in0=int64#4
# asm 2: movq <j0=56(%rsp),>in0=%rcx
movq 56(%rsp),%rcx
# qhasm: out0 = in0
# asm 1: mov <in0=int64#4,>out0=int64#3
# asm 2: mov <in0=%rcx,>out0=%rdx
mov %rcx,%rdx
# qhasm: (uint64) out0 >>= 32
# asm 1: shr $32,<out0=int64#3
# asm 2: shr $32,<out0=%rdx
shr $32,%rdx
# qhasm: (uint32) in0 += x0
# asm 1: addl <x0=stack64#20,<in0=int64#4d
# asm 2: addl <x0=152(%rsp),<in0=%ecx
addl 152(%rsp),%ecx
# qhasm: (uint32) out0 += x1
# asm 1: addl <x1=stack64#28,<out0=int64#3d
# asm 2: addl <x1=216(%rsp),<out0=%edx
addl 216(%rsp),%edx
# qhasm: out0 <<= 32
# asm 1: shl $32,<out0=int64#3
# asm 2: shl $32,<out0=%rdx
shl $32,%rdx
# qhasm: out0 ^= in0
# asm 1: xor <in0=int64#4,<out0=int64#3
# asm 2: xor <in0=%rcx,<out0=%rdx
xor %rcx,%rdx
# qhasm: out0 ^= *(uint64 *) (m + 0)
# asm 1: xorq 0(<m=int64#2),<out0=int64#3
# asm 2: xorq 0(<m=%rsi),<out0=%rdx
xorq 0(%rsi),%rdx
# qhasm: *(uint64 *) (out + 0) = out0
# asm 1: movq <out0=int64#3,0(<out=int64#1)
# asm 2: movq <out0=%rdx,0(<out=%rdi)
movq %rdx,0(%rdi)
# qhasm: in2 = j2
# asm 1: movq <j2=stack64#9,>in2=int64#6
# asm 2: movq <j2=64(%rsp),>in2=%r9
movq 64(%rsp),%r9
# qhasm: out2 = in2
# asm 1: mov <in2=int64#6,>out2=int64#3
# asm 2: mov <in2=%r9,>out2=%rdx
mov %r9,%rdx
# qhasm: (uint64) out2 >>= 32
# asm 1: shr $32,<out2=int64#3
# asm 2: shr $32,<out2=%rdx
shr $32,%rdx
# qhasm: (uint32) in2 += x2
# asm 1: addl <x2=stack64#21,<in2=int64#6d
# asm 2: addl <x2=160(%rsp),<in2=%r9d
addl 160(%rsp),%r9d
# qhasm: (uint32) out2 += x3
# asm 1: addl <x3=stack64#29,<out2=int64#3d
# asm 2: addl <x3=224(%rsp),<out2=%edx
addl 224(%rsp),%edx
# qhasm: out2 <<= 32
# asm 1: shl $32,<out2=int64#3
# asm 2: shl $32,<out2=%rdx
shl $32,%rdx
# qhasm: out2 ^= in2
# asm 1: xor <in2=int64#6,<out2=int64#3
# asm 2: xor <in2=%r9,<out2=%rdx
xor %r9,%rdx
# qhasm: out2 ^= *(uint64 *) (m + 8)
# asm 1: xorq 8(<m=int64#2),<out2=int64#3
# asm 2: xorq 8(<m=%rsi),<out2=%rdx
xorq 8(%rsi),%rdx
# qhasm: *(uint64 *) (out + 8) = out2
# asm 1: movq <out2=int64#3,8(<out=int64#1)
# asm 2: movq <out2=%rdx,8(<out=%rdi)
movq %rdx,8(%rdi)
# qhasm: in4 = j4
# asm 1: movq <j4=stack64#10,>in4=int64#7
# asm 2: movq <j4=72(%rsp),>in4=%rax
movq 72(%rsp),%rax
# qhasm: out4 = in4
# asm 1: mov <in4=int64#7,>out4=int64#3
# asm 2: mov <in4=%rax,>out4=%rdx
mov %rax,%rdx
# qhasm: (uint64) out4 >>= 32
# asm 1: shr $32,<out4=int64#3
# asm 2: shr $32,<out4=%rdx
shr $32,%rdx
# qhasm: (uint32) in4 += x4
# asm 1: addl <x4=stack64#22,<in4=int64#7d
# asm 2: addl <x4=168(%rsp),<in4=%eax
addl 168(%rsp),%eax
# qhasm: (uint32) out4 += x5
# asm 1: addl <x5=stack64#30,<out4=int64#3d
# asm 2: addl <x5=232(%rsp),<out4=%edx
addl 232(%rsp),%edx
# qhasm: out4 <<= 32
# asm 1: shl $32,<out4=int64#3
# asm 2: shl $32,<out4=%rdx
shl $32,%rdx
# qhasm: out4 ^= in4
# asm 1: xor <in4=int64#7,<out4=int64#3
# asm 2: xor <in4=%rax,<out4=%rdx
xor %rax,%rdx
# qhasm: out4 ^= *(uint64 *) (m + 16)
# asm 1: xorq 16(<m=int64#2),<out4=int64#3
# asm 2: xorq 16(<m=%rsi),<out4=%rdx
xorq 16(%rsi),%rdx
# qhasm: *(uint64 *) (out + 16) = out4
# asm 1: movq <out4=int64#3,16(<out=int64#1)
# asm 2: movq <out4=%rdx,16(<out=%rdi)
movq %rdx,16(%rdi)
# qhasm: in6 = j6
# asm 1: movq <j6=stack64#11,>in6=int64#8
# asm 2: movq <j6=80(%rsp),>in6=%r10
movq 80(%rsp),%r10
# qhasm: out6 = in6
# asm 1: mov <in6=int64#8,>out6=int64#3
# asm 2: mov <in6=%r10,>out6=%rdx
mov %r10,%rdx
# qhasm: (uint64) out6 >>= 32
# asm 1: shr $32,<out6=int64#3
# asm 2: shr $32,<out6=%rdx
shr $32,%rdx
# qhasm: (uint32) in6 += x6
# asm 1: addl <x6=stack64#23,<in6=int64#8d
# asm 2: addl <x6=176(%rsp),<in6=%r10d
addl 176(%rsp),%r10d
# qhasm: (uint32) out6 += x7
# asm 1: addl <x7=stack64#31,<out6=int64#3d
# asm 2: addl <x7=240(%rsp),<out6=%edx
addl 240(%rsp),%edx
# qhasm: out6 <<= 32
# asm 1: shl $32,<out6=int64#3
# asm 2: shl $32,<out6=%rdx
shl $32,%rdx
# qhasm: out6 ^= in6
# asm 1: xor <in6=int64#8,<out6=int64#3
# asm 2: xor <in6=%r10,<out6=%rdx
xor %r10,%rdx
# qhasm: out6 ^= *(uint64 *) (m + 24)
# asm 1: xorq 24(<m=int64#2),<out6=int64#3
# asm 2: xorq 24(<m=%rsi),<out6=%rdx
xorq 24(%rsi),%rdx
# qhasm: *(uint64 *) (out + 24) = out6
# asm 1: movq <out6=int64#3,24(<out=int64#1)
# asm 2: movq <out6=%rdx,24(<out=%rdi)
movq %rdx,24(%rdi)
# qhasm: in8 = j8
# asm 1: movq <j8=stack64#12,>in8=int64#3
# asm 2: movq <j8=88(%rsp),>in8=%rdx
movq 88(%rsp),%rdx
# qhasm: out8 = in8
# asm 1: mov <in8=int64#3,>out8=int64#4
# asm 2: mov <in8=%rdx,>out8=%rcx
mov %rdx,%rcx
# qhasm: (uint64) out8 >>= 32
# asm 1: shr $32,<out8=int64#4
# asm 2: shr $32,<out8=%rcx
shr $32,%rcx
# qhasm: (uint32) in8 += x8
# asm 1: addl <x8=stack64#24,<in8=int64#3d
# asm 2: addl <x8=184(%rsp),<in8=%edx
addl 184(%rsp),%edx
# qhasm: (uint32) out8 += x9
# asm 1: addl <x9=stack64#32,<out8=int64#4d
# asm 2: addl <x9=248(%rsp),<out8=%ecx
addl 248(%rsp),%ecx
# qhasm: out8 <<= 32
# asm 1: shl $32,<out8=int64#4
# asm 2: shl $32,<out8=%rcx
shl $32,%rcx
# qhasm: out8 ^= in8
# asm 1: xor <in8=int64#3,<out8=int64#4
# asm 2: xor <in8=%rdx,<out8=%rcx
xor %rdx,%rcx
# qhasm: out8 ^= *(uint64 *) (m + 32)
# asm 1: xorq 32(<m=int64#2),<out8=int64#4
# asm 2: xorq 32(<m=%rsi),<out8=%rcx
xorq 32(%rsi),%rcx
# qhasm: *(uint64 *) (out + 32) = out8
# asm 1: movq <out8=int64#4,32(<out=int64#1)
# asm 2: movq <out8=%rcx,32(<out=%rdi)
movq %rcx,32(%rdi)
# qhasm: in10 = j10
# asm 1: movq <j10=stack64#13,>in10=int64#10
# asm 2: movq <j10=96(%rsp),>in10=%r12
movq 96(%rsp),%r12
# qhasm: out10 = in10
# asm 1: mov <in10=int64#10,>out10=int64#3
# asm 2: mov <in10=%r12,>out10=%rdx
mov %r12,%rdx
# qhasm: (uint64) out10 >>= 32
# asm 1: shr $32,<out10=int64#3
# asm 2: shr $32,<out10=%rdx
shr $32,%rdx
# qhasm: (uint32) in10 += x10
# asm 1: addl <x10=stack64#25,<in10=int64#10d
# asm 2: addl <x10=192(%rsp),<in10=%r12d
addl 192(%rsp),%r12d
# qhasm: (uint32) out10 += x11
# asm 1: addl <x11=stack64#33,<out10=int64#3d
# asm 2: addl <x11=256(%rsp),<out10=%edx
addl 256(%rsp),%edx
# qhasm: out10 <<= 32
# asm 1: shl $32,<out10=int64#3
# asm 2: shl $32,<out10=%rdx
shl $32,%rdx
# qhasm: out10 ^= in10
# asm 1: xor <in10=int64#10,<out10=int64#3
# asm 2: xor <in10=%r12,<out10=%rdx
xor %r12,%rdx
# qhasm: out10 ^= *(uint64 *) (m + 40)
# asm 1: xorq 40(<m=int64#2),<out10=int64#3
# asm 2: xorq 40(<m=%rsi),<out10=%rdx
xorq 40(%rsi),%rdx
# qhasm: *(uint64 *) (out + 40) = out10
# asm 1: movq <out10=int64#3,40(<out=int64#1)
# asm 2: movq <out10=%rdx,40(<out=%rdi)
movq %rdx,40(%rdi)
# qhasm: in12 = j12
# asm 1: movq <j12=stack64#14,>in12=int64#11
# asm 2: movq <j12=104(%rsp),>in12=%r13
movq 104(%rsp),%r13
# qhasm: out12 = in12
# asm 1: mov <in12=int64#11,>out12=int64#3
# asm 2: mov <in12=%r13,>out12=%rdx
mov %r13,%rdx
# qhasm: (uint64) out12 >>= 32
# asm 1: shr $32,<out12=int64#3
# asm 2: shr $32,<out12=%rdx
shr $32,%rdx
# qhasm: (uint32) in12 += x12
# asm 1: addl <x12=stack64#26,<in12=int64#11d
# asm 2: addl <x12=200(%rsp),<in12=%r13d
addl 200(%rsp),%r13d
# qhasm: (uint32) out12 += x13
# asm 1: addl <x13=stack64#34,<out12=int64#3d
# asm 2: addl <x13=264(%rsp),<out12=%edx
addl 264(%rsp),%edx
# qhasm: out12 <<= 32
# asm 1: shl $32,<out12=int64#3
# asm 2: shl $32,<out12=%rdx
shl $32,%rdx
# qhasm: out12 ^= in12
# asm 1: xor <in12=int64#11,<out12=int64#3
# asm 2: xor <in12=%r13,<out12=%rdx
xor %r13,%rdx
# qhasm: out12 ^= *(uint64 *) (m + 48)
# asm 1: xorq 48(<m=int64#2),<out12=int64#3
# asm 2: xorq 48(<m=%rsi),<out12=%rdx
xorq 48(%rsi),%rdx
# qhasm: *(uint64 *) (out + 48) = out12
# asm 1: movq <out12=int64#3,48(<out=int64#1)
# asm 2: movq <out12=%rdx,48(<out=%rdi)
movq %rdx,48(%rdi)
# qhasm: in14 = j14
# asm 1: movq <j14=stack64#15,>in14=int64#12
# asm 2: movq <j14=112(%rsp),>in14=%r14
movq 112(%rsp),%r14
# qhasm: out14 = in14
# asm 1: mov <in14=int64#12,>out14=int64#3
# asm 2: mov <in14=%r14,>out14=%rdx
mov %r14,%rdx
# qhasm: (uint64) out14 >>= 32
# asm 1: shr $32,<out14=int64#3
# asm 2: shr $32,<out14=%rdx
shr $32,%rdx
# qhasm: (uint32) in14 += x14
# asm 1: addl <x14=stack64#27,<in14=int64#12d
# asm 2: addl <x14=208(%rsp),<in14=%r14d
addl 208(%rsp),%r14d
# qhasm: (uint32) out14 += x15
# asm 1: addl <x15=stack64#35,<out14=int64#3d
# asm 2: addl <x15=272(%rsp),<out14=%edx
addl 272(%rsp),%edx
# qhasm: out14 <<= 32
# asm 1: shl $32,<out14=int64#3
# asm 2: shl $32,<out14=%rdx
shl $32,%rdx
# qhasm: out14 ^= in14
# asm 1: xor <in14=int64#12,<out14=int64#3
# asm 2: xor <in14=%r14,<out14=%rdx
xor %r14,%rdx
# qhasm: out14 ^= *(uint64 *) (m + 56)
# asm 1: xorq 56(<m=int64#2),<out14=int64#3
# asm 2: xorq 56(<m=%rsi),<out14=%rdx
xorq 56(%rsi),%rdx
# qhasm: *(uint64 *) (out + 56) = out14
# asm 1: movq <out14=int64#3,56(<out=int64#1)
# asm 2: movq <out14=%rdx,56(<out=%rdi)
movq %rdx,56(%rdi)
# qhasm: bytes = bytes_backup
# asm 1: movq <bytes_backup=stack64#19,>bytes=int64#3
# asm 2: movq <bytes_backup=144(%rsp),>bytes=%rdx
movq 144(%rsp),%rdx
# qhasm: in8 = j8
# asm 1: movq <j8=stack64#12,>in8=int64#9
# asm 2: movq <j8=88(%rsp),>in8=%r11
movq 88(%rsp),%r11
# qhasm: in8 += 1
# asm 1: add $1,<in8=int64#9
# asm 2: add $1,<in8=%r11
add $1,%r11
# qhasm: j8 = in8
# asm 1: movq <in8=int64#9,>j8=stack64#12
# asm 2: movq <in8=%r11,>j8=88(%rsp)
movq %r11,88(%rsp)
# qhasm: unsigned>? unsigned<? bytes - 64
# asm 1: cmp $64,<bytes=int64#3
# asm 2: cmp $64,<bytes=%rdx
cmp $64,%rdx
# comment:fp stack unchanged by jump
# qhasm: goto bytesatleast65 if unsigned>
ja ._bytesatleast65
# comment:fp stack unchanged by jump
# qhasm: goto bytesatleast64 if !unsigned<
jae ._bytesatleast64
# qhasm: m = out
# asm 1: mov <out=int64#1,>m=int64#2
# asm 2: mov <out=%rdi,>m=%rsi
mov %rdi,%rsi
# qhasm: out = ctarget
# asm 1: mov <ctarget=int64#5,>out=int64#1
# asm 2: mov <ctarget=%r8,>out=%rdi
mov %r8,%rdi
# qhasm: i = bytes
# asm 1: mov <bytes=int64#3,>i=int64#4
# asm 2: mov <bytes=%rdx,>i=%rcx
mov %rdx,%rcx
# qhasm: while (i) { *out++ = *m++; --i }
rep movsb
# comment:fp stack unchanged by fallthrough
# qhasm: bytesatleast64:
._bytesatleast64:
# qhasm: x = x_backup
# asm 1: movq <x_backup=stack64#16,>x=int64#5
# asm 2: movq <x_backup=120(%rsp),>x=%r8
movq 120(%rsp),%r8
# qhasm: in8 = j8
# asm 1: movq <j8=stack64#12,>in8=int64#1
# asm 2: movq <j8=88(%rsp),>in8=%rdi
movq 88(%rsp),%rdi
# qhasm: *(uint64 *) (x + 32) = in8
# asm 1: movq <in8=int64#1,32(<x=int64#5)
# asm 2: movq <in8=%rdi,32(<x=%r8)
movq %rdi,32(%r8)
# qhasm: r11 = r11_stack
# asm 1: movq <r11_stack=stack64#1,>r11=int64#9
# asm 2: movq <r11_stack=0(%rsp),>r11=%r11
movq 0(%rsp),%r11
# qhasm: r12 = r12_stack
# asm 1: movq <r12_stack=stack64#2,>r12=int64#10
# asm 2: movq <r12_stack=8(%rsp),>r12=%r12
movq 8(%rsp),%r12
# qhasm: r13 = r13_stack
# asm 1: movq <r13_stack=stack64#3,>r13=int64#11
# asm 2: movq <r13_stack=16(%rsp),>r13=%r13
movq 16(%rsp),%r13
# qhasm: r14 = r14_stack
# asm 1: movq <r14_stack=stack64#4,>r14=int64#12
# asm 2: movq <r14_stack=24(%rsp),>r14=%r14
movq 24(%rsp),%r14
# qhasm: r15 = r15_stack
# asm 1: movq <r15_stack=stack64#5,>r15=int64#13
# asm 2: movq <r15_stack=32(%rsp),>r15=%r15
movq 32(%rsp),%r15
# qhasm: rbx = rbx_stack
# asm 1: movq <rbx_stack=stack64#6,>rbx=int64#14
# asm 2: movq <rbx_stack=40(%rsp),>rbx=%rbx
movq 40(%rsp),%rbx
# qhasm: rbp = rbp_stack
# asm 1: movq <rbp_stack=stack64#7,>rbp=int64#15
# asm 2: movq <rbp_stack=48(%rsp),>rbp=%rbp
movq 48(%rsp),%rbp
# comment:fp stack unchanged by fallthrough
# qhasm: done:
._done:
# qhasm: leave
add %r11,%rsp
mov %rdi,%rax
mov %rsi,%rdx
ret
# qhasm: bytesatleast65:
._bytesatleast65:
# qhasm: bytes -= 64
# asm 1: sub $64,<bytes=int64#3
# asm 2: sub $64,<bytes=%rdx
sub $64,%rdx
# qhasm: out += 64
# asm 1: add $64,<out=int64#1
# asm 2: add $64,<out=%rdi
add $64,%rdi
# qhasm: m += 64
# asm 1: add $64,<m=int64#2
# asm 2: add $64,<m=%rsi
add $64,%rsi
# comment:fp stack unchanged by jump
# qhasm: goto bytesatleast1
jmp ._bytesatleast1
# qhasm: enter ECRYPT_init
.text
.p2align 5
.globl _ECRYPT_init
.globl ECRYPT_init
_ECRYPT_init:
ECRYPT_init:
mov %rsp,%r11
and $31,%r11
add $352,%r11
sub %r11,%rsp
# qhasm: leave
add %r11,%rsp
mov %rdi,%rax
mov %rsi,%rdx
ret
# qhasm: enter ECRYPT_keysetup
.text
.p2align 5
.globl _ECRYPT_keysetup
.globl ECRYPT_keysetup
_ECRYPT_keysetup:
ECRYPT_keysetup:
mov %rsp,%r11
and $31,%r11
add $352,%r11
sub %r11,%rsp
# qhasm: k = arg2
# asm 1: mov <arg2=int64#2,>k=int64#2
# asm 2: mov <arg2=%rsi,>k=%rsi
mov %rsi,%rsi
# qhasm: kbits = arg3
# asm 1: mov <arg3=int64#3,>kbits=int64#3
# asm 2: mov <arg3=%rdx,>kbits=%rdx
mov %rdx,%rdx
# qhasm: x = arg1
# asm 1: mov <arg1=int64#1,>x=int64#1
# asm 2: mov <arg1=%rdi,>x=%rdi
mov %rdi,%rdi
# qhasm: in0 = *(uint64 *) (k + 0)
# asm 1: movq 0(<k=int64#2),>in0=int64#5
# asm 2: movq 0(<k=%rsi),>in0=%r8
movq 0(%rsi),%r8
# qhasm: in2 = *(uint64 *) (k + 8)
# asm 1: movq 8(<k=int64#2),>in2=int64#6
# asm 2: movq 8(<k=%rsi),>in2=%r9
movq 8(%rsi),%r9
# qhasm: *(uint64 *) (x + 4) = in0
# asm 1: movq <in0=int64#5,4(<x=int64#1)
# asm 2: movq <in0=%r8,4(<x=%rdi)
movq %r8,4(%rdi)
# qhasm: *(uint64 *) (x + 12) = in2
# asm 1: movq <in2=int64#6,12(<x=int64#1)
# asm 2: movq <in2=%r9,12(<x=%rdi)
movq %r9,12(%rdi)
# qhasm: unsigned<? kbits - 256
# asm 1: cmp $256,<kbits=int64#3
# asm 2: cmp $256,<kbits=%rdx
cmp $256,%rdx
# comment:fp stack unchanged by jump
# qhasm: goto kbits128 if unsigned<
jb ._kbits128
# qhasm: kbits256:
._kbits256:
# qhasm: in10 = *(uint64 *) (k + 16)
# asm 1: movq 16(<k=int64#2),>in10=int64#3
# asm 2: movq 16(<k=%rsi),>in10=%rdx
movq 16(%rsi),%rdx
# qhasm: in12 = *(uint64 *) (k + 24)
# asm 1: movq 24(<k=int64#2),>in12=int64#2
# asm 2: movq 24(<k=%rsi),>in12=%rsi
movq 24(%rsi),%rsi
# qhasm: *(uint64 *) (x + 44) = in10
# asm 1: movq <in10=int64#3,44(<x=int64#1)
# asm 2: movq <in10=%rdx,44(<x=%rdi)
movq %rdx,44(%rdi)
# qhasm: *(uint64 *) (x + 52) = in12
# asm 1: movq <in12=int64#2,52(<x=int64#1)
# asm 2: movq <in12=%rsi,52(<x=%rdi)
movq %rsi,52(%rdi)
# qhasm: in0 = 1634760805
# asm 1: mov $1634760805,>in0=int64#2
# asm 2: mov $1634760805,>in0=%rsi
mov $1634760805,%rsi
# qhasm: in4 = 857760878
# asm 1: mov $857760878,>in4=int64#3
# asm 2: mov $857760878,>in4=%rdx
mov $857760878,%rdx
# qhasm: in10 = 2036477234
# asm 1: mov $2036477234,>in10=int64#4
# asm 2: mov $2036477234,>in10=%rcx
mov $2036477234,%rcx
# qhasm: in14 = 1797285236
# asm 1: mov $1797285236,>in14=int64#5
# asm 2: mov $1797285236,>in14=%r8
mov $1797285236,%r8
# qhasm: *(uint32 *) (x + 0) = in0
# asm 1: movl <in0=int64#2d,0(<x=int64#1)
# asm 2: movl <in0=%esi,0(<x=%rdi)
movl %esi,0(%rdi)
# qhasm: *(uint32 *) (x + 20) = in4
# asm 1: movl <in4=int64#3d,20(<x=int64#1)
# asm 2: movl <in4=%edx,20(<x=%rdi)
movl %edx,20(%rdi)
# qhasm: *(uint32 *) (x + 40) = in10
# asm 1: movl <in10=int64#4d,40(<x=int64#1)
# asm 2: movl <in10=%ecx,40(<x=%rdi)
movl %ecx,40(%rdi)
# qhasm: *(uint32 *) (x + 60) = in14
# asm 1: movl <in14=int64#5d,60(<x=int64#1)
# asm 2: movl <in14=%r8d,60(<x=%rdi)
movl %r8d,60(%rdi)
# comment:fp stack unchanged by jump
# qhasm: goto keysetupdone
jmp ._keysetupdone
# qhasm: kbits128:
._kbits128:
# qhasm: in10 = *(uint64 *) (k + 0)
# asm 1: movq 0(<k=int64#2),>in10=int64#3
# asm 2: movq 0(<k=%rsi),>in10=%rdx
movq 0(%rsi),%rdx
# qhasm: in12 = *(uint64 *) (k + 8)
# asm 1: movq 8(<k=int64#2),>in12=int64#2
# asm 2: movq 8(<k=%rsi),>in12=%rsi
movq 8(%rsi),%rsi
# qhasm: *(uint64 *) (x + 44) = in10
# asm 1: movq <in10=int64#3,44(<x=int64#1)
# asm 2: movq <in10=%rdx,44(<x=%rdi)
movq %rdx,44(%rdi)
# qhasm: *(uint64 *) (x + 52) = in12
# asm 1: movq <in12=int64#2,52(<x=int64#1)
# asm 2: movq <in12=%rsi,52(<x=%rdi)
movq %rsi,52(%rdi)
# qhasm: in0 = 1634760805
# asm 1: mov $1634760805,>in0=int64#2
# asm 2: mov $1634760805,>in0=%rsi
mov $1634760805,%rsi
# qhasm: in4 = 824206446
# asm 1: mov $824206446,>in4=int64#3
# asm 2: mov $824206446,>in4=%rdx
mov $824206446,%rdx
# qhasm: in10 = 2036477238
# asm 1: mov $2036477238,>in10=int64#4
# asm 2: mov $2036477238,>in10=%rcx
mov $2036477238,%rcx
# qhasm: in14 = 1797285236
# asm 1: mov $1797285236,>in14=int64#5
# asm 2: mov $1797285236,>in14=%r8
mov $1797285236,%r8
# qhasm: *(uint32 *) (x + 0) = in0
# asm 1: movl <in0=int64#2d,0(<x=int64#1)
# asm 2: movl <in0=%esi,0(<x=%rdi)
movl %esi,0(%rdi)
# qhasm: *(uint32 *) (x + 20) = in4
# asm 1: movl <in4=int64#3d,20(<x=int64#1)
# asm 2: movl <in4=%edx,20(<x=%rdi)
movl %edx,20(%rdi)
# qhasm: *(uint32 *) (x + 40) = in10
# asm 1: movl <in10=int64#4d,40(<x=int64#1)
# asm 2: movl <in10=%ecx,40(<x=%rdi)
movl %ecx,40(%rdi)
# qhasm: *(uint32 *) (x + 60) = in14
# asm 1: movl <in14=int64#5d,60(<x=int64#1)
# asm 2: movl <in14=%r8d,60(<x=%rdi)
movl %r8d,60(%rdi)
# qhasm: keysetupdone:
._keysetupdone:
# qhasm: leave
add %r11,%rsp
mov %rdi,%rax
mov %rsi,%rdx
ret
# qhasm: enter ECRYPT_ivsetup
.text
.p2align 5
.globl _ECRYPT_ivsetup
.globl ECRYPT_ivsetup
_ECRYPT_ivsetup:
ECRYPT_ivsetup:
mov %rsp,%r11
and $31,%r11
add $352,%r11
sub %r11,%rsp
# qhasm: iv = arg2
# asm 1: mov <arg2=int64#2,>iv=int64#2
# asm 2: mov <arg2=%rsi,>iv=%rsi
mov %rsi,%rsi
# qhasm: x = arg1
# asm 1: mov <arg1=int64#1,>x=int64#1
# asm 2: mov <arg1=%rdi,>x=%rdi
mov %rdi,%rdi
# qhasm: in6 = *(uint64 *) (iv + 0)
# asm 1: movq 0(<iv=int64#2),>in6=int64#2
# asm 2: movq 0(<iv=%rsi),>in6=%rsi
movq 0(%rsi),%rsi
# qhasm: in8 = 0
# asm 1: mov $0,>in8=int64#5
# asm 2: mov $0,>in8=%r8
mov $0,%r8
# qhasm: *(uint64 *) (x + 24) = in6
# asm 1: movq <in6=int64#2,24(<x=int64#1)
# asm 2: movq <in6=%rsi,24(<x=%rdi)
movq %rsi,24(%rdi)
# qhasm: *(uint64 *) (x + 32) = in8
# asm 1: movq <in8=int64#5,32(<x=int64#1)
# asm 2: movq <in8=%r8,32(<x=%rdi)
movq %r8,32(%rdi)
# qhasm: leave
add %r11,%rsp
mov %rdi,%rax
mov %rsi,%rdx
ret
|
eSTREAM Project Powered by ViewCVS 1.0-dev |
ViewCVS and CVS Help |