void xor (unsigned long long *block, unsigned long long *xkey) {
  register int i = 64;
  while (i--) {
    block[i] ^= xkey[i];
  }
}


x86 assembly (clang, -O0):
<xor>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x40,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x14(%rbp)
cmp    $0x0,%eax
je     1148 <xor+0x48>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
xor    (%rax,%rcx,8),%rdx
mov    %rdx,(%rax,%rcx,8)
jmp    1113 <xor+0x13>
pop    %rbp
ret

x86 assembly (clang, -O2):
<xor>:
lea    0x200(%rsi),%rax
cmp    %rdi,%rax
jbe    116c <xor+0x6c>
lea    0x200(%rdi),%rax
cmp    %rsi,%rax
jbe    116c <xor+0x6c>
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
mov    0x1f8(%rsi,%rax,8),%rcx
xor    %rcx,0x1f8(%rdi,%rax,8)
mov    0x1f0(%rsi,%rax,8),%rcx
xor    %rcx,0x1f0(%rdi,%rax,8)
mov    0x1e8(%rsi,%rax,8),%rcx
xor    %rcx,0x1e8(%rdi,%rax,8)
mov    0x1e0(%rsi,%rax,8),%rcx
xor    %rcx,0x1e0(%rdi,%rax,8)
add    $0xfffffffffffffffc,%rax
cmp    $0xffffffffffffffc0,%rax
jne    1120 <xor+0x20>
jmp    11e6 <xor+0xe6>
xor    %eax,%eax
xchg   %ax,%ax
movups 0x1f0(%rsi,%rax,8),%xmm0
movups 0x1c0(%rdi,%rax,8),%xmm1
movups 0x1d0(%rdi,%rax,8),%xmm2
movups 0x1e0(%rdi,%rax,8),%xmm3
movups 0x1f0(%rdi,%rax,8),%xmm4
xorps  %xmm0,%xmm4
movups %xmm4,0x1f0(%rdi,%rax,8)
movups 0x1e0(%rsi,%rax,8),%xmm0
xorps  %xmm3,%xmm0
movups %xmm0,0x1e0(%rdi,%rax,8)
movups 0x1d0(%rsi,%rax,8),%xmm0
xorps  %xmm2,%xmm0
movups %xmm0,0x1d0(%rdi,%rax,8)
movups 0x1c0(%rsi,%rax,8),%xmm0
xorps  %xmm1,%xmm0
movups %xmm0,0x1c0(%rdi,%rax,8)
add    $0xfffffffffffffff8,%rax
cmp    $0xffffffffffffffc0,%rax
jne    1170 <xor+0x70>
ret

LLVM IR (-O0):
define void @xor(i64* %0, i64* %1) {
%3 = alloca i64*
%4 = alloca i64*
%5 = alloca i32
store i64* %0, i64** %3
store i64* %1, i64** %4
store i32 64, i32* %5
br label %6
6: ; preds = %10, %2
%7 = load i32, i32* %5
%8 = add nsw i32 %7, -1
store i32 %8, i32* %5
%9 = icmp ne i32 %7, 0
br i1 %9, label %10, label %22
10: ; preds = %6
%11 = load i64*, i64** %4
%12 = load i32, i32* %5
%13 = sext i32 %12 to i64
%14 = getelementptr inbounds i64, i64* %11, i64 %13
%15 = load i64, i64* %14
%16 = load i64*, i64** %3
%17 = load i32, i32* %5
%18 = sext i32 %17 to i64
%19 = getelementptr inbounds i64, i64* %16, i64 %18
%20 = load i64, i64* %19
%21 = xor i64 %20, %15
store i64 %21, i64* %19
br label %6
22: ; preds = %6
ret void
}

LLVM IR (-O2):
define void @xor(i64* nocapture %0, i64* nocapture %1) {
%3 = getelementptr i64, i64* %0, i64 64
%4 = getelementptr i64, i64* %1, i64 64
%5 = icmp ugt i64* %4, %0
%6 = icmp ugt i64* %3, %1
%7 = and i1 %5, %6
br i1 %7, label %57, label %8
8: ; preds = %2
%9 = getelementptr inbounds i64, i64* %1, i64 -1
%10 = getelementptr inbounds i64, i64* %0, i64 -1
%11 = getelementptr inbounds i64, i64* %1, i64 -1
%12 = getelementptr inbounds i64, i64* %0, i64 -1
%13 = getelementptr inbounds i64, i64* %1, i64 -1
%14 = getelementptr inbounds i64, i64* %0, i64 -1
%15 = getelementptr inbounds i64, i64* %1, i64 -1
%16 = getelementptr inbounds i64, i64* %0, i64 -1
br label %17
17: ; preds = %17, %8
%18 = phi i64 [ 0, %8 ], [ %55, %17 ]
%19 = sub nuw nsw i64 63, %18
%20 = getelementptr inbounds i64, i64* %9, i64 %19
%21 = bitcast i64* %20 to <2 x i64>*
%22 = load <2 x i64>, <2 x i64>* %21
%23 = getelementptr inbounds i64, i64* %10, i64 %19
%24 = bitcast i64* %23 to <2 x i64>*
%25 = load <2 x i64>, <2 x i64>* %24
%26 = xor <2 x i64> %25, %22
%27 = bitcast i64* %23 to <2 x i64>*
store <2 x i64> %26, <2 x i64>* %27
%28 = sub nsw i64 61, %18
%29 = getelementptr inbounds i64, i64* %11, i64 %28
%30 = bitcast i64* %29 to <2 x i64>*
%31 = load <2 x i64>, <2 x i64>* %30
%32 = getelementptr inbounds i64, i64* %12, i64 %28
%33 = bitcast i64* %32 to <2 x i64>*
%34 = load <2 x i64>, <2 x i64>* %33
%35 = xor <2 x i64> %34, %31
%36 = bitcast i64* %32 to <2 x i64>*
store <2 x i64> %35, <2 x i64>* %36
%37 = sub nsw i64 59, %18
%38 = getelementptr inbounds i64, i64* %13, i64 %37
%39 = bitcast i64* %38 to <2 x i64>*
%40 = load <2 x i64>, <2 x i64>* %39
%41 = getelementptr inbounds i64, i64* %14, i64 %37
%42 = bitcast i64* %41 to <2 x i64>*
%43 = load <2 x i64>, <2 x i64>* %42
%44 = xor <2 x i64> %43, %40
%45 = bitcast i64* %41 to <2 x i64>*
store <2 x i64> %44, <2 x i64>* %45
%46 = sub nsw i64 57, %18
%47 = getelementptr inbounds i64, i64* %15, i64 %46
%48 = bitcast i64* %47 to <2 x i64>*
%49 = load <2 x i64>, <2 x i64>* %48
%50 = getelementptr inbounds i64, i64* %16, i64 %46
%51 = bitcast i64* %50 to <2 x i64>*
%52 = load <2 x i64>, <2 x i64>* %51
%53 = xor <2 x i64> %52, %49
%54 = bitcast i64* %50 to <2 x i64>*
store <2 x i64> %53, <2 x i64>* %54
%55 = add nuw nsw i64 %18, 8
%56 = icmp eq i64 %55, 64
br i1 %56, label %84, label %17
57: ; preds = %2, %57
%58 = phi i64 [ %82, %57 ], [ 63, %2 ]
%59 = getelementptr inbounds i64, i64* %1, i64 %58
%60 = load i64, i64* %59
%61 = getelementptr inbounds i64, i64* %0, i64 %58
%62 = load i64, i64* %61
%63 = xor i64 %62, %60
store i64 %63, i64* %61
%64 = add nsw i64 %58, -1
%65 = getelementptr inbounds i64, i64* %1, i64 %64
%66 = load i64, i64* %65
%67 = getelementptr inbounds i64, i64* %0, i64 %64
%68 = load i64, i64* %67
%69 = xor i64 %68, %66
store i64 %69, i64* %67
%70 = add nsw i64 %58, -2
%71 = getelementptr inbounds i64, i64* %1, i64 %70
%72 = load i64, i64* %71
%73 = getelementptr inbounds i64, i64* %0, i64 %70
%74 = load i64, i64* %73
%75 = xor i64 %74, %72
store i64 %75, i64* %73
%76 = add nsw i64 %58, -3
%77 = getelementptr inbounds i64, i64* %1, i64 %76
%78 = load i64, i64* %77
%79 = getelementptr inbounds i64, i64* %0, i64 %76
%80 = load i64, i64* %79
%81 = xor i64 %80, %78
store i64 %81, i64* %79
%82 = add nsw i64 %58, -4
%83 = icmp eq i64 %76, 0
br i1 %83, label %84, label %57
84: ; preds = %17, %57
ret void
}