void mm(float *a, float *b, int n) {
  int t2;
  int i;
  for (t2 = 0; t2 <= n - 1; t2 += 1) {
    a[t2] = b[t2];
    b[t2] = (a[t2] + 1);
  }
}


x86 assembly (clang, -O0):
<mm>:
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
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1171 <mm+0x71>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  0xeaf(%rip),%xmm0
addss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1116 <mm+0x16>
pop    %rbp
ret

x86 assembly (clang, -O2):
<mm>:
test   %edx,%edx
jle    1256 <mm+0x156>
mov    %edx,%r9d
cmp    $0x8,%edx
jb     1122 <mm+0x22>
lea    (%rsi,%r9,4),%rax
cmp    %rdi,%rax
jbe    1197 <mm+0x97>
lea    (%rdi,%r9,4),%rax
cmp    %rsi,%rax
jbe    1197 <mm+0x97>
xor    %ecx,%ecx
mov    %rcx,%rax
not    %rax
test   $0x1,%r9b
je     114b <mm+0x4b>
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdi,%rcx,4)
addss  0xece(%rip),%xmm0
movss  %xmm0,(%rsi,%rcx,4)
or     $0x1,%rcx
add    %r9,%rax
je     1256 <mm+0x156>
movss  0xeb4(%rip),%xmm0
nopl   0x0(%rax)
movss  (%rsi,%rcx,4),%xmm1
movss  %xmm1,(%rdi,%rcx,4)
addss  %xmm0,%xmm1
movss  %xmm1,(%rsi,%rcx,4)
movss  0x4(%rsi,%rcx,4),%xmm1
movss  %xmm1,0x4(%rdi,%rcx,4)
addss  %xmm0,%xmm1
movss  %xmm1,0x4(%rsi,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%r9
jne    1160 <mm+0x60>
jmp    1256 <mm+0x156>
mov    %r9d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     1257 <mm+0x157>
mov    %r8,%rax
and    $0xfffffffffffffffe,%rax
xor    %edx,%edx
movaps 0xe3b(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nop
movups (%rsi,%rdx,4),%xmm1
movups 0x10(%rsi,%rdx,4),%xmm2
movups %xmm1,(%rdi,%rdx,4)
movups %xmm2,0x10(%rdi,%rdx,4)
addps  %xmm0,%xmm1
addps  %xmm0,%xmm2
movups %xmm1,(%rsi,%rdx,4)
movups %xmm2,0x10(%rsi,%rdx,4)
movups 0x20(%rsi,%rdx,4),%xmm1
movups 0x30(%rsi,%rdx,4),%xmm2
movups %xmm1,0x20(%rdi,%rdx,4)
movups %xmm2,0x30(%rdi,%rdx,4)
addps  %xmm0,%xmm1
addps  %xmm0,%xmm2
movups %xmm1,0x20(%rsi,%rdx,4)
movups %xmm2,0x30(%rsi,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rax
jne    11d0 <mm+0xd0>
test   $0x1,%r8b
je     124d <mm+0x14d>
movups (%rsi,%rdx,4),%xmm0
movups 0x10(%rsi,%rdx,4),%xmm1
movups %xmm0,(%rdi,%rdx,4)
movups %xmm1,0x10(%rdi,%rdx,4)
movaps 0xdc2(%rip),%xmm2
addps  %xmm2,%xmm0
addps  %xmm2,%xmm1
movups %xmm0,(%rsi,%rdx,4)
movups %xmm1,0x10(%rsi,%rdx,4)
cmp    %r9,%rcx
jne    1124 <mm+0x24>
ret
xor    %edx,%edx
test   $0x1,%r8b
jne    1225 <mm+0x125>
jmp    124d <mm+0x14d>

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

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