void changeArays(int *arrA, int *arrB, int size) {
  for (int i = 0; i < size; i++) {
    int tmp = arrA[i];
    arrA[i] = arrB[i];
    arrB[i] = tmp;
  }
}


x86 assembly (clang, -O0):
<changeArays>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1162 <changeArays+0x62>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%edx
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1116 <changeArays+0x16>
pop    %rbp
ret

x86 assembly (clang, -O2):
<changeArays>:
test   %edx,%edx
jle    1239 <changeArays+0x139>
mov    %edx,%r9d
cmp    $0x8,%edx
jb     1122 <changeArays+0x22>
lea    (%rsi,%r9,4),%rax
cmp    %rdi,%rax
jbe    117a <changeArays+0x7a>
lea    (%rdi,%r9,4),%rax
cmp    %rsi,%rax
jbe    117a <changeArays+0x7a>
xor    %ecx,%ecx
mov    %rcx,%rax
not    %rax
test   $0x1,%r9b
je     1142 <changeArays+0x42>
mov    (%rdi,%rcx,4),%r8d
mov    (%rsi,%rcx,4),%edx
mov    %edx,(%rdi,%rcx,4)
mov    %r8d,(%rsi,%rcx,4)
or     $0x1,%rcx
add    %r9,%rax
je     1239 <changeArays+0x139>
nopl   0x0(%rax,%rax,1)
mov    (%rdi,%rcx,4),%eax
mov    (%rsi,%rcx,4),%edx
mov    %edx,(%rdi,%rcx,4)
mov    %eax,(%rsi,%rcx,4)
mov    0x4(%rdi,%rcx,4),%eax
mov    0x4(%rsi,%rcx,4),%edx
mov    %edx,0x4(%rdi,%rcx,4)
mov    %eax,0x4(%rsi,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%r9
jne    1150 <changeArays+0x50>
jmp    1239 <changeArays+0x139>
mov    %r9d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     123a <changeArays+0x13a>
mov    %r8,%rax
and    $0xfffffffffffffffe,%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rdi,%rdx,4),%xmm0
movups 0x10(%rdi,%rdx,4),%xmm1
movups (%rsi,%rdx,4),%xmm2
movups 0x10(%rsi,%rdx,4),%xmm3
movups %xmm2,(%rdi,%rdx,4)
movups %xmm3,0x10(%rdi,%rdx,4)
movups %xmm0,(%rsi,%rdx,4)
movups %xmm1,0x10(%rsi,%rdx,4)
movups 0x20(%rdi,%rdx,4),%xmm0
movups 0x30(%rdi,%rdx,4),%xmm1
movups 0x20(%rsi,%rdx,4),%xmm2
movups 0x30(%rsi,%rdx,4),%xmm3
movups %xmm2,0x20(%rdi,%rdx,4)
movups %xmm3,0x30(%rdi,%rdx,4)
movups %xmm0,0x20(%rsi,%rdx,4)
movups %xmm1,0x30(%rsi,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rax
jne    11b0 <changeArays+0xb0>
test   $0x1,%r8b
je     1230 <changeArays+0x130>
movups (%rdi,%rdx,4),%xmm0
movups 0x10(%rdi,%rdx,4),%xmm1
movups (%rsi,%rdx,4),%xmm2
movups 0x10(%rsi,%rdx,4),%xmm3
movups %xmm2,(%rdi,%rdx,4)
movups %xmm3,0x10(%rdi,%rdx,4)
movups %xmm0,(%rsi,%rdx,4)
movups %xmm1,0x10(%rsi,%rdx,4)
cmp    %r9,%rcx
jne    1124 <changeArays+0x24>
ret
xor    %edx,%edx
test   $0x1,%r8b
jne    120c <changeArays+0x10c>
jmp    1230 <changeArays+0x130>

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

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