void shuffle_sb(int *k, unsigned saltbits) {
  unsigned j;
  int x;
  for (j = 4096; j--;) {
    x = (k[0] ^ k[1]) & (int)saltbits;
    *k++ ^= x;
    *k++ ^= x;
  }
}


x86 assembly (clang, -O0):
<shuffle_sb>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movl   $0x1000,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x10(%rbp)
cmp    $0x0,%eax
je     116a <shuffle_sb+0x6a>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    -0x8(%rbp),%rcx
xor    0x4(%rcx),%eax
and    -0xc(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x8(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x14(%rbp),%ecx
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x8(%rbp)
xor    (%rax),%ecx
mov    %ecx,(%rax)
jmp    1112 <shuffle_sb+0x12>
pop    %rbp
ret

x86 assembly (clang, -O2):
<shuffle_sb>:
movd   %esi,%xmm0
pshufd $0x50,%xmm0,%xmm0
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movdqu (%rdi,%rax,8),%xmm1
movdqu 0x10(%rdi,%rax,8),%xmm2
pshufd $0xe8,%xmm1,%xmm3
pshufd $0xed,%xmm1,%xmm1
movdqa %xmm1,%xmm4
pxor   %xmm3,%xmm4
pand   %xmm0,%xmm4
pxor   %xmm4,%xmm3
pxor   %xmm1,%xmm4
punpckldq %xmm4,%xmm3
movdqu %xmm3,(%rdi,%rax,8)
pshufd $0xe8,%xmm2,%xmm1
pshufd $0xed,%xmm2,%xmm2
movdqa %xmm2,%xmm3
pxor   %xmm1,%xmm3
pand   %xmm0,%xmm3
pxor   %xmm3,%xmm1
pxor   %xmm2,%xmm3
punpckldq %xmm3,%xmm1
movdqu %xmm1,0x10(%rdi,%rax,8)
add    $0x4,%rax
cmp    $0x1000,%rax
jne    1110 <shuffle_sb+0x10>
ret

LLVM IR (-O0):
define void @shuffle_sb(i32* %0, i32 %1) {
%3 = alloca i32*
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
store i32* %0, i32** %3
store i32 %1, i32* %4
store i32 4096, i32* %5
br label %7
7: ; preds = %11, %2
%8 = load i32, i32* %5
%9 = add i32 %8, -1
store i32 %9, i32* %5
%10 = icmp ne i32 %8, 0
br i1 %10, label %11, label %31
11: ; preds = %7
%12 = load i32*, i32** %3
%13 = getelementptr inbounds i32, i32* %12, i64 0
%14 = load i32, i32* %13
%15 = load i32*, i32** %3
%16 = getelementptr inbounds i32, i32* %15, i64 1
%17 = load i32, i32* %16
%18 = xor i32 %14, %17
%19 = load i32, i32* %4
%20 = and i32 %18, %19
store i32 %20, i32* %6
%21 = load i32, i32* %6
%22 = load i32*, i32** %3
%23 = getelementptr inbounds i32, i32* %22, i32 1
store i32* %23, i32** %3
%24 = load i32, i32* %22
%25 = xor i32 %24, %21
store i32 %25, i32* %22
%26 = load i32, i32* %6
%27 = load i32*, i32** %3
%28 = getelementptr inbounds i32, i32* %27, i32 1
store i32* %28, i32** %3
%29 = load i32, i32* %27
%30 = xor i32 %29, %26
store i32 %30, i32* %27
br label %7
31: ; preds = %7
ret void
}

LLVM IR (-O2):
define void @shuffle_sb(i32* nocapture %0, i32 %1) {
%3 = insertelement <2 x i32> poison, i32 %1, i64 0
%4 = shufflevector <2 x i32> %3, <2 x i32> poison, <2 x i32> zeroinitializer
br label %5
5: ; preds = %5, %2
%6 = phi i64 [ 0, %2 ], [ %36, %5 ]
%7 = shl nuw i64 %6, 1
%8 = getelementptr i32, i32* %0, i64 %7
%9 = bitcast i32* %8 to <4 x i32>*
%10 = load <4 x i32>, <4 x i32>* %9
%11 = shufflevector <4 x i32> %10, <4 x i32> poison, <2 x i32> <i32 0, i32 2>
%12 = shufflevector <4 x i32> %10, <4 x i32> poison, <2 x i32> <i32 1, i32 3>
%13 = getelementptr inbounds i32, i32* %8, i64 1
%14 = xor <2 x i32> %12, %11
%15 = and <2 x i32> %14, %4
%16 = xor <2 x i32> %15, %11
%17 = xor <2 x i32> %15, %12
%18 = getelementptr inbounds i32, i32* %13, i64 -1
%19 = bitcast i32* %18 to <4 x i32>*
%20 = shufflevector <2 x i32> %16, <2 x i32> %17, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x i32> %20, <4 x i32>* %19
%21 = shl nuw i64 %6, 1
%22 = or i64 %21, 4
%23 = getelementptr i32, i32* %0, i64 %22
%24 = bitcast i32* %23 to <4 x i32>*
%25 = load <4 x i32>, <4 x i32>* %24
%26 = shufflevector <4 x i32> %25, <4 x i32> poison, <2 x i32> <i32 0, i32 2>
%27 = shufflevector <4 x i32> %25, <4 x i32> poison, <2 x i32> <i32 1, i32 3>
%28 = getelementptr inbounds i32, i32* %23, i64 1
%29 = xor <2 x i32> %27, %26
%30 = and <2 x i32> %29, %4
%31 = xor <2 x i32> %30, %26
%32 = xor <2 x i32> %30, %27
%33 = getelementptr inbounds i32, i32* %28, i64 -1
%34 = bitcast i32* %33 to <4 x i32>*
%35 = shufflevector <2 x i32> %31, <2 x i32> %32, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x i32> %35, <4 x i32>* %34
%36 = add nuw nsw i64 %6, 4
%37 = icmp eq i64 %36, 4096
br i1 %37, label %38, label %5
38: ; preds = %5
ret void
}