void __attribute__((no, noclone))
test_float(float *restrict a, float *restrict b, int step) {
  step = step & 7;
  for (int i = 0; i < 87; ++i) {
    float r1 = a[i * step + 0] += 1;
    a[i * step + 1] += 2;
    a[i * step + 2] += 4;
    a[i * step + 3] += 8;
    b[i] += r1;
  }
}


x86 assembly (clang, -O0):
<test_float>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x14(%rbp),%eax
and    $0x7,%eax
mov    %eax,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
cmpl   $0x57,-0x18(%rbp)
jge    11df <test_float+0xdf>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  0xeca(%rip),%xmm0
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  %xmm0,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  0xe9e(%rip),%xmm0
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  0xe77(%rip),%xmm0
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  0xe50(%rip),%xmm0
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    111f <test_float+0x1f>
pop    %rbp
ret

x86 assembly (clang, -O2):
<test_float>:
and    $0x7,%edx
lea    0x0(,%rdx,8),%rax
mov    $0x1,%ecx
movaps 0xee9(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
movups (%rdi),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,(%rdi)
addss  -0x4(%rsi,%rcx,4),%xmm1
movss  %xmm1,-0x4(%rsi,%rcx,4)
cmp    $0x57,%rcx
je     1159 <test_float+0x59>
movups (%rdi,%rdx,4),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,(%rdi,%rdx,4)
addss  (%rsi,%rcx,4),%xmm1
movss  %xmm1,(%rsi,%rcx,4)
add    $0x2,%rcx
add    %rax,%rdi
jmp    1120 <test_float+0x20>
ret

LLVM IR (-O0):
define void @test_float(float* noalias %0, float* noalias %1, i32 %2) {
%4 = alloca float*
%5 = alloca float*
%6 = alloca i32
%7 = alloca i32
%8 = alloca float
store float* %0, float** %4
store float* %1, float** %5
store i32 %2, i32* %6
%9 = load i32, i32* %6
%10 = and i32 %9, 7
store i32 %10, i32* %6
store i32 0, i32* %7
br label %11
11: ; preds = %58, %3
%12 = load i32, i32* %7
%13 = icmp slt i32 %12, 87
br i1 %13, label %14, label %61
14: ; preds = %11
%15 = load float*, float** %4
%16 = load i32, i32* %7
%17 = load i32, i32* %6
%18 = mul nsw i32 %16, %17
%19 = add nsw i32 %18, 0
%20 = sext i32 %19 to i64
%21 = getelementptr inbounds float, float* %15, i64 %20
%22 = load float, float* %21
%23 = fadd float %22, 1.000000e+00
store float %23, float* %21
store float %23, float* %8
%24 = load float*, float** %4
%25 = load i32, i32* %7
%26 = load i32, i32* %6
%27 = mul nsw i32 %25, %26
%28 = add nsw i32 %27, 1
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds float, float* %24, i64 %29
%31 = load float, float* %30
%32 = fadd float %31, 2.000000e+00
store float %32, float* %30
%33 = load float*, float** %4
%34 = load i32, i32* %7
%35 = load i32, i32* %6
%36 = mul nsw i32 %34, %35
%37 = add nsw i32 %36, 2
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds float, float* %33, i64 %38
%40 = load float, float* %39
%41 = fadd float %40, 4.000000e+00
store float %41, float* %39
%42 = load float*, float** %4
%43 = load i32, i32* %7
%44 = load i32, i32* %6
%45 = mul nsw i32 %43, %44
%46 = add nsw i32 %45, 3
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds float, float* %42, i64 %47
%49 = load float, float* %48
%50 = fadd float %49, 8.000000e+00
store float %50, float* %48
%51 = load float, float* %8
%52 = load float*, float** %5
%53 = load i32, i32* %7
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds float, float* %52, i64 %54
%56 = load float, float* %55
%57 = fadd float %56, %51
store float %57, float* %55
br label %58
58: ; preds = %14
%59 = load i32, i32* %7
%60 = add nsw i32 %59, 1
store i32 %60, i32* %7
br label %11
61: ; preds = %11
ret void
}

LLVM IR (-O2):
define void @test_float(float* noalias nocapture %0, float* noalias nocapture %1, i32 %2) {
%4 = and i32 %2, 7
%5 = zext i32 %4 to i64
br label %7
6: ; preds = %7
ret void
7: ; preds = %21, %3
%8 = phi i64 [ 0, %3 ], [ %32, %21 ]
%9 = mul nuw nsw i64 %8, %5
%10 = getelementptr inbounds float, float* %0, i64 %9
%11 = bitcast float* %10 to <4 x float>*
%12 = load <4 x float>, <4 x float>* %11
%13 = fadd <4 x float> %12, <float 1.000000e+00, float 2.000000e+00, float 4.000000e+00, float 8.000000e+00>
%14 = bitcast float* %10 to <4 x float>*
store <4 x float> %13, <4 x float>* %14
%15 = getelementptr inbounds float, float* %1, i64 %8
%16 = load float, float* %15
%17 = extractelement <4 x float> %13, i64 0
%18 = fadd float %17, %16
store float %18, float* %15
%19 = or i64 %8, 1
%20 = icmp eq i64 %19, 87
br i1 %20, label %6, label %21
21: ; preds = %7
%22 = mul nuw nsw i64 %19, %5
%23 = getelementptr inbounds float, float* %0, i64 %22
%24 = bitcast float* %23 to <4 x float>*
%25 = load <4 x float>, <4 x float>* %24
%26 = fadd <4 x float> %25, <float 1.000000e+00, float 2.000000e+00, float 4.000000e+00, float 8.000000e+00>
%27 = bitcast float* %23 to <4 x float>*
store <4 x float> %26, <4 x float>* %27
%28 = getelementptr inbounds float, float* %1, i64 %19
%29 = load float, float* %28
%30 = extractelement <4 x float> %26, i64 0
%31 = fadd float %30, %29
store float %31, float* %28
%32 = add nuw nsw i64 %8, 2
br label %7
}