void CopyArray(int B[], int n, int A[]) {
  int c = n;
  while (c > 0) {
    B[1] = A[1];
    c--;
    A++;
    B++;
  }
}


x86 assembly (clang, -O0):
<CopyArray>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jle    1153 <CopyArray+0x53>
mov    -0x18(%rbp),%rax
mov    0x4(%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x8(%rbp)
jmp    1115 <CopyArray+0x15>
pop    %rbp
ret

x86 assembly (clang, -O2):
<CopyArray>:
test   %esi,%esi
jle    1242 <CopyArray+0x142>
lea    -0x1(%rsi),%r9d
cmp    $0x7,%r9d
jb     121d <CopyArray+0x11d>
lea    0x4(%rdi),%rax
lea    (%rdx,%r9,4),%rcx
add    $0x8,%rcx
cmp    %rcx,%rax
jae    113c <CopyArray+0x3c>
lea    (%rdi,%r9,4),%rax
add    $0x8,%rax
lea    0x4(%rdx),%rcx
cmp    %rax,%rcx
jb     121d <CopyArray+0x11d>
add    $0x1,%r9
mov    %r9,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rax
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %ecx,%r10d
and    $0x3,%r10d
cmp    $0x18,%rax
jae    1167 <CopyArray+0x67>
xor    %eax,%eax
jmp    11ca <CopyArray+0xca>
and    $0xfffffffffffffffc,%rcx
xor    %eax,%eax
nopl   (%rax)
movups 0x4(%rdx,%rax,4),%xmm0
movups 0x14(%rdx,%rax,4),%xmm1
movups %xmm0,0x4(%rdi,%rax,4)
movups %xmm1,0x14(%rdi,%rax,4)
movups 0x24(%rdx,%rax,4),%xmm0
movups 0x34(%rdx,%rax,4),%xmm1
movups %xmm0,0x24(%rdi,%rax,4)
movups %xmm1,0x34(%rdi,%rax,4)
movups 0x44(%rdx,%rax,4),%xmm0
movups 0x54(%rdx,%rax,4),%xmm1
movups %xmm0,0x44(%rdi,%rax,4)
movups %xmm1,0x54(%rdi,%rax,4)
movups 0x64(%rdx,%rax,4),%xmm0
movups 0x74(%rdx,%rax,4),%xmm1
movups %xmm0,0x64(%rdi,%rax,4)
movups %xmm1,0x74(%rdi,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%rcx
jne    1170 <CopyArray+0x70>
test   %r10,%r10
je     120d <CopyArray+0x10d>
lea    (%rdi,%rax,4),%r11
add    $0x14,%r11
lea    (%rdx,%rax,4),%rax
add    $0x14,%rax
shl    $0x5,%r10
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x10(%rax,%rcx,1),%xmm0
movups (%rax,%rcx,1),%xmm1
movups %xmm0,-0x10(%r11,%rcx,1)
movups %xmm1,(%r11,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%r10
jne    11f0 <CopyArray+0xf0>
cmp    %r8,%r9
je     1242 <CopyArray+0x142>
sub    %r8d,%esi
lea    (%rdx,%r8,4),%rdx
lea    (%rdi,%r8,4),%rdi
add    $0x1,%esi
mov    $0x4,%eax
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rdx,%rax,1),%ecx
mov    %ecx,(%rdi,%rax,1)
add    $0xffffffff,%esi
add    $0x4,%rax
cmp    $0x1,%esi
ja     1230 <CopyArray+0x130>
ret

LLVM IR (-O0):
define void @CopyArray(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* %5
store i32 %8, i32* %7
br label %9
9: ; preds = %12, %3
%10 = load i32, i32* %7
%11 = icmp sgt i32 %10, 0
br i1 %11, label %12, label %24
12: ; preds = %9
%13 = load i32*, i32** %6
%14 = getelementptr inbounds i32, i32* %13, i64 1
%15 = load i32, i32* %14
%16 = load i32*, i32** %4
%17 = getelementptr inbounds i32, i32* %16, i64 1
store i32 %15, i32* %17
%18 = load i32, i32* %7
%19 = add nsw i32 %18, -1
store i32 %19, i32* %7
%20 = load i32*, i32** %6
%21 = getelementptr inbounds i32, i32* %20, i32 1
store i32* %21, i32** %6
%22 = load i32*, i32** %4
%23 = getelementptr inbounds i32, i32* %22, i32 1
store i32* %23, i32** %4
br label %9
24: ; preds = %9
ret void
}

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