void pfblk(int nblks, int *xblk, int *list) {
  int *stop;
  stop = list + nblks;
  for (; list <= stop; list++, xblk++)
    *xblk = *list;
  return;
}


x86 assembly (clang, -O0):
<pfblk>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x4(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
cmp    -0x20(%rbp),%rax
ja     1159 <pfblk+0x59>
mov    -0x18(%rbp),%rax
mov    (%rax),%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x18(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x10(%rbp)
jmp    1122 <pfblk+0x22>
pop    %rbp
ret

x86 assembly (clang, -O2):
<pfblk>:
test   %edi,%edi
js     1171 <pfblk+0x71>
movslq %edi,%r9
lea    (%rdx,%r9,4),%rcx
add    $0x1,%rcx
lea    0x4(%rdx),%rax
cmp    %rax,%rcx
mov    %rax,%r10
cmova  %rcx,%r10
mov    %rdx,%rdi
not    %rdi
add    %rdi,%r10
cmp    $0x1c,%r10
jb     1153 <pfblk+0x53>
cmp    %rax,%rcx
cmova  %rcx,%rax
add    %rdi,%rax
and    $0xfffffffffffffffc,%rax
lea    (%rdx,%rax,1),%rcx
add    $0x4,%rcx
cmp    %rsi,%rcx
jbe    1172 <pfblk+0x72>
add    %rsi,%rax
add    $0x4,%rax
cmp    %rdx,%rax
jbe    1172 <pfblk+0x72>
mov    %rdx,%rax
lea    (%rdx,%r9,4),%rcx
nopw   0x0(%rax,%rax,1)
mov    (%rax),%edx
mov    %edx,(%rsi)
add    $0x4,%rax
add    $0x4,%rsi
cmp    %rcx,%rax
jbe    1160 <pfblk+0x60>
ret
shr    $0x2,%r10
add    $0x1,%r10
mov    %r10,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rax
mov    %rax,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%r11d
and    $0x3,%r11d
cmp    $0x18,%rax
jae    11a1 <pfblk+0xa1>
xor    %ecx,%ecx
jmp    1208 <pfblk+0x108>
and    $0xfffffffffffffffc,%rdi
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movups (%rdx,%rcx,4),%xmm0
movups 0x10(%rdx,%rcx,4),%xmm1
movups %xmm0,(%rsi,%rcx,4)
movups %xmm1,0x10(%rsi,%rcx,4)
movups 0x20(%rdx,%rcx,4),%xmm0
movups 0x30(%rdx,%rcx,4),%xmm1
movups %xmm0,0x20(%rsi,%rcx,4)
movups %xmm1,0x30(%rsi,%rcx,4)
movups 0x40(%rdx,%rcx,4),%xmm0
movups 0x50(%rdx,%rcx,4),%xmm1
movups %xmm0,0x40(%rsi,%rcx,4)
movups %xmm1,0x50(%rsi,%rcx,4)
movups 0x60(%rdx,%rcx,4),%xmm0
movups 0x70(%rdx,%rcx,4),%xmm1
movups %xmm0,0x60(%rsi,%rcx,4)
movups %xmm1,0x70(%rsi,%rcx,4)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rdi
jne    11b0 <pfblk+0xb0>
test   %r11,%r11
je     124b <pfblk+0x14b>
lea    (%rdx,%rcx,4),%rdi
add    $0x10,%rdi
lea    (%rsi,%rcx,4),%rcx
add    $0x10,%rcx
shl    $0x5,%r11
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rdi,%rax,1),%xmm0
movups (%rdi,%rax,1),%xmm1
movups %xmm0,-0x10(%rcx,%rax,1)
movups %xmm1,(%rcx,%rax,1)
add    $0x20,%rax
cmp    %rax,%r11
jne    1230 <pfblk+0x130>
cmp    %r8,%r10
je     1171 <pfblk+0x71>
lea    (%rsi,%r8,4),%rsi
lea    (%rdx,%r8,4),%rax
jmp    1156 <pfblk+0x56>

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

LLVM IR (-O2):
define void @pfblk(i32 %0, i32* nocapture writeonly %1, i32* %2) {
%4 = ptrtoint i32* %2 to i64
%5 = ptrtoint i32* %2 to i64
%6 = sext i32 %0 to i64
%7 = getelementptr inbounds i32, i32* %2, i64 %6
%8 = icmp slt i32 %0, 0
br i1 %8, label %126, label %9
9: ; preds = %3
%10 = shl nsw i64 %6, 2
%11 = add i64 %10, %4
%12 = add i64 %11, 1
%13 = add i64 %4, 4
%14 = call i64 @llvm.umax.i64(i64 %12, i64 %13)
%15 = xor i64 %4, -1
%16 = add i64 %14, %15
%17 = lshr i64 %16, 2
%18 = add nuw nsw i64 %17, 1
%19 = icmp ult i64 %16, 28
br i1 %19, label %116, label %20
20: ; preds = %9
%21 = shl nsw i64 %6, 2
%22 = add i64 %21, %5
%23 = add i64 %22, 1
%24 = add i64 %5, 4
%25 = call i64 @llvm.umax.i64(i64 %23, i64 %24)
%26 = xor i64 %5, -1
%27 = add i64 %25, %26
%28 = lshr i64 %27, 2
%29 = add nuw nsw i64 %28, 1
%30 = getelementptr i32, i32* %1, i64 %29
%31 = getelementptr i32, i32* %2, i64 %29
%32 = icmp ugt i32* %31, %1
%33 = icmp ugt i32* %30, %2
%34 = and i1 %32, %33
br i1 %34, label %116, label %35
35: ; preds = %20
%36 = and i64 %18, 9223372036854775800
%37 = getelementptr i32, i32* %1, i64 %36
%38 = getelementptr i32, i32* %2, i64 %36
%39 = add nsw i64 %36, -8
%40 = lshr exact i64 %39, 3
%41 = add nuw nsw i64 %40, 1
%42 = and i64 %41, 3
%43 = icmp ult i64 %39, 24
br i1 %43, label %95, label %44
44: ; preds = %35
%45 = and i64 %41, 4611686018427387900
br label %46
46: ; preds = %46, %44
%47 = phi i64 [ 0, %44 ], [ %92, %46 ]
%48 = phi i64 [ 0, %44 ], [ %93, %46 ]
%49 = getelementptr i32, i32* %1, i64 %47
%50 = getelementptr i32, i32* %2, i64 %47
%51 = bitcast i32* %50 to <4 x i32>*
%52 = load <4 x i32>, <4 x i32>* %51
%53 = getelementptr i32, i32* %50, i64 4
%54 = bitcast i32* %53 to <4 x i32>*
%55 = load <4 x i32>, <4 x i32>* %54
%56 = bitcast i32* %49 to <4 x i32>*
store <4 x i32> %52, <4 x i32>* %56
%57 = getelementptr i32, i32* %49, i64 4
%58 = bitcast i32* %57 to <4 x i32>*
store <4 x i32> %55, <4 x i32>* %58
%59 = or i64 %47, 8
%60 = getelementptr i32, i32* %1, i64 %59
%61 = getelementptr i32, i32* %2, i64 %59
%62 = bitcast i32* %61 to <4 x i32>*
%63 = load <4 x i32>, <4 x i32>* %62
%64 = getelementptr i32, i32* %61, i64 4
%65 = bitcast i32* %64 to <4 x i32>*
%66 = load <4 x i32>, <4 x i32>* %65
%67 = bitcast i32* %60 to <4 x i32>*
store <4 x i32> %63, <4 x i32>* %67
%68 = getelementptr i32, i32* %60, i64 4
%69 = bitcast i32* %68 to <4 x i32>*
store <4 x i32> %66, <4 x i32>* %69
%70 = or i64 %47, 16
%71 = getelementptr i32, i32* %1, i64 %70
%72 = getelementptr i32, i32* %2, i64 %70
%73 = bitcast i32* %72 to <4 x i32>*
%74 = load <4 x i32>, <4 x i32>* %73
%75 = getelementptr i32, i32* %72, i64 4
%76 = bitcast i32* %75 to <4 x i32>*
%77 = load <4 x i32>, <4 x i32>* %76
%78 = bitcast i32* %71 to <4 x i32>*
store <4 x i32> %74, <4 x i32>* %78
%79 = getelementptr i32, i32* %71, i64 4
%80 = bitcast i32* %79 to <4 x i32>*
store <4 x i32> %77, <4 x i32>* %80
%81 = or i64 %47, 24
%82 = getelementptr i32, i32* %1, i64 %81
%83 = getelementptr i32, i32* %2, i64 %81
%84 = bitcast i32* %83 to <4 x i32>*
%85 = load <4 x i32>, <4 x i32>* %84
%86 = getelementptr i32, i32* %83, i64 4
%87 = bitcast i32* %86 to <4 x i32>*
%88 = load <4 x i32>, <4 x i32>* %87
%89 = bitcast i32* %82 to <4 x i32>*
store <4 x i32> %85, <4 x i32>* %89
%90 = getelementptr i32, i32* %82, i64 4
%91 = bitcast i32* %90 to <4 x i32>*
store <4 x i32> %88, <4 x i32>* %91
%92 = add nuw i64 %47, 32
%93 = add i64 %48, 4
%94 = icmp eq i64 %93, %45
br i1 %94, label %95, label %46
95: ; preds = %46, %35
%96 = phi i64 [ 0, %35 ], [ %92, %46 ]
%97 = icmp eq i64 %42, 0
br i1 %97, label %114, label %98
98: ; preds = %95, %98
%99 = phi i64 [ %111, %98 ], [ %96, %95 ]
%100 = phi i64 [ %112, %98 ], [ 0, %95 ]
%101 = getelementptr i32, i32* %1, i64 %99
%102 = getelementptr i32, i32* %2, i64 %99
%103 = bitcast i32* %102 to <4 x i32>*
%104 = load <4 x i32>, <4 x i32>* %103
%105 = getelementptr i32, i32* %102, i64 4
%106 = bitcast i32* %105 to <4 x i32>*
%107 = load <4 x i32>, <4 x i32>* %106
%108 = bitcast i32* %101 to <4 x i32>*
store <4 x i32> %104, <4 x i32>* %108
%109 = getelementptr i32, i32* %101, i64 4
%110 = bitcast i32* %109 to <4 x i32>*
store <4 x i32> %107, <4 x i32>* %110
%111 = add nuw i64 %99, 8
%112 = add i64 %100, 1
%113 = icmp eq i64 %112, %42
br i1 %113, label %114, label %98
114: ; preds = %98, %95
%115 = icmp eq i64 %18, %36
br i1 %115, label %126, label %116
116: ; preds = %20, %9, %114
%117 = phi i32* [ %1, %20 ], [ %1, %9 ], [ %37, %114 ]
%118 = phi i32* [ %2, %20 ], [ %2, %9 ], [ %38, %114 ]
br label %119
119: ; preds = %116, %119
%120 = phi i32* [ %124, %119 ], [ %117, %116 ]
%121 = phi i32* [ %123, %119 ], [ %118, %116 ]
%122 = load i32, i32* %121
store i32 %122, i32* %120
%123 = getelementptr inbounds i32, i32* %121, i64 1
%124 = getelementptr inbounds i32, i32* %120, i64 1
%125 = icmp ugt i32* %123, %7
br i1 %125, label %126, label %119
126: ; preds = %119, %114, %3
ret void
}