float getInterpolatedValue(float value, float *array) {
  int roundedValue = (int)value;
  float decimalPart = value - roundedValue;
  if (decimalPart > 0.0f) {
    float diff = array[roundedValue + 1] - array[roundedValue];
    return array[roundedValue] + (decimalPart * diff);
  } else {
    return array[roundedValue];
  }
}


x86 assembly (clang, -O0):
<getInterpolatedValue>:
push   %rbp
mov    %rsp,%rbp
movss  %xmm0,-0x8(%rbp)
mov    %rdi,-0x10(%rbp)
cvttss2si -0x8(%rbp),%eax
mov    %eax,-0x14(%rbp)
movss  -0x8(%rbp),%xmm0
cvtsi2ssl -0x14(%rbp),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x18(%rbp)
movss  -0x18(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1186 <getInterpolatedValue+0x86>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x18(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4(%rbp)
jmp    1198 <getInterpolatedValue+0x98>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4(%rbp)
movss  -0x4(%rbp),%xmm0
pop    %rbp
ret

x86 assembly (clang, -O2):
<getInterpolatedValue>:
cvttss2si %xmm0,%eax
cvttps2dq %xmm0,%xmm1
cvtdq2ps %xmm1,%xmm1
subss  %xmm1,%xmm0
xorps  %xmm1,%xmm1
cltq
ucomiss %xmm1,%xmm0
jbe    1131 <getInterpolatedValue+0x31>
movss  (%rdi,%rax,4),%xmm1
movss  0x4(%rdi,%rax,4),%xmm2
subss  %xmm1,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
ret
movss  (%rdi,%rax,4),%xmm0
ret

LLVM IR (-O0):
define float @getInterpolatedValue(float %0, float* %1) {
%3 = alloca float
%4 = alloca float
%5 = alloca float*
%6 = alloca i32
%7 = alloca float
%8 = alloca float
store float %0, float* %4
store float* %1, float** %5
%9 = load float, float* %4
%10 = fptosi float %9 to i32
store i32 %10, i32* %6
%11 = load float, float* %4
%12 = load i32, i32* %6
%13 = sitofp i32 %12 to float
%14 = fsub float %11, %13
store float %14, float* %7
%15 = load float, float* %7
%16 = fcmp ogt float %15, 0.000000e+00
br i1 %16, label %17, label %38
17: ; preds = %2
%18 = load float*, float** %5
%19 = load i32, i32* %6
%20 = add nsw i32 %19, 1
%21 = sext i32 %20 to i64
%22 = getelementptr inbounds float, float* %18, i64 %21
%23 = load float, float* %22
%24 = load float*, float** %5
%25 = load i32, i32* %6
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds float, float* %24, i64 %26
%28 = load float, float* %27
%29 = fsub float %23, %28
store float %29, float* %8
%30 = load float*, float** %5
%31 = load i32, i32* %6
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds float, float* %30, i64 %32
%34 = load float, float* %33
%35 = load float, float* %7
%36 = load float, float* %8
%37 = call float @llvm.fmuladd.f32(float %35, float %36, float %34)
store float %37, float* %3
br label %44
38: ; preds = %2
%39 = load float*, float** %5
%40 = load i32, i32* %6
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds float, float* %39, i64 %41
%43 = load float, float* %42
store float %43, float* %3
br label %44
44: ; preds = %38, %17
%45 = load float, float* %3
ret float %45
}

LLVM IR (-O2):
define float @getInterpolatedValue(float %0, float* nocapture %1) {
%3 = fptosi float %0 to i32
%4 = sitofp i32 %3 to float
%5 = fsub float %0, %4
%6 = fcmp ogt float %5, 0.000000e+00
br i1 %6, label %7, label %17
7: ; preds = %2
%8 = add nsw i32 %3, 1
%9 = sext i32 %8 to i64
%10 = getelementptr inbounds float, float* %1, i64 %9
%11 = load float, float* %10
%12 = sext i32 %3 to i64
%13 = getelementptr inbounds float, float* %1, i64 %12
%14 = load float, float* %13
%15 = fsub float %11, %14
%16 = tail call float @llvm.fmuladd.f32(float %5, float %15, float %14)
br label %21
17: ; preds = %2
%18 = sext i32 %3 to i64
%19 = getelementptr inbounds float, float* %1, i64 %18
%20 = load float, float* %19
br label %21
21: ; preds = %17, %7
%22 = phi float [ %16, %7 ], [ %20, %17 ]
ret float %22
}