float chbevlf(x, array, n)
float x;
float *array;
int n;
{
  float b0, b1, b2, *p;
  int i;
  p = array;
  b0 = *p++;
  b1 = 0.0;
  i = n - 1;
  do {
    b2 = b1;
    b1 = b0;
    b0 = x * b1 - b2 + *p++;
  } while (--i);
  return (0.5 * (b0 - b2));
}


x86 assembly (clang, -O0):
<chbevlf>:
push   %rbp
mov    %rsp,%rbp
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4(%rbp)
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x28(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x18(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
movss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x18(%rbp),%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x4(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm2
movss  -0x20(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x28(%rbp)
addss  (%rax),%xmm0
movss  %xmm0,-0x18(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
cmp    $0x0,%eax
jne    1145 <chbevlf+0x45>
movss  -0x18(%rbp),%xmm0
subss  -0x20(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe43(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
pop    %rbp
ret

x86 assembly (clang, -O2):
<chbevlf>:
cvtsd2ss %xmm0,%xmm1
movss  (%rdi),%xmm0
lea    -0x1(%rsi),%eax
lea    -0x2(%rsi),%ecx
test   $0x3,%al
je     115e <chbevlf+0x5e>
add    $0xff,%sil
movzbl %sil,%edx
and    $0x3,%edx
xorps  %xmm4,%xmm4
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movaps %xmm0,%xmm2
movaps %xmm4,%xmm3
movaps %xmm1,%xmm0
mulss  %xmm2,%xmm0
subss  %xmm4,%xmm0
addss  0x4(%rdi),%xmm0
add    $0x4,%rdi
add    $0x1,%rsi
movaps %xmm2,%xmm4
cmp    %esi,%edx
jne    1130 <chbevlf+0x30>
sub    %esi,%eax
cmp    $0x3,%ecx
jae    1166 <chbevlf+0x66>
jmp    11bc <chbevlf+0xbc>
xorps  %xmm2,%xmm2
cmp    $0x3,%ecx
jb     11bc <chbevlf+0xbc>
mov    %eax,%eax
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movaps %xmm1,%xmm4
mulss  %xmm0,%xmm4
subss  %xmm2,%xmm4
addss  0x4(%rdi,%rcx,4),%xmm4
movaps %xmm1,%xmm3
mulss  %xmm4,%xmm3
subss  %xmm0,%xmm3
addss  0x8(%rdi,%rcx,4),%xmm3
movaps %xmm1,%xmm2
mulss  %xmm3,%xmm2
subss  %xmm4,%xmm2
addss  0xc(%rdi,%rcx,4),%xmm2
movaps %xmm1,%xmm0
mulss  %xmm2,%xmm0
subss  %xmm3,%xmm0
addss  0x10(%rdi,%rcx,4),%xmm0
add    $0x4,%rcx
cmp    %ecx,%eax
jne    1170 <chbevlf+0x70>
subss  %xmm3,%xmm0
mulss  0xe38(%rip),%xmm0
ret

LLVM IR (-O0):
define float @chbevlf(double %0, float* %1, i32 %2) {
%4 = alloca float
%5 = alloca float*
%6 = alloca i32
%7 = alloca float
%8 = alloca float
%9 = alloca float
%10 = alloca float*
%11 = alloca i32
%12 = fptrunc double %0 to float
store float %12, float* %4
store float* %1, float** %5
store i32 %2, i32* %6
%13 = load float*, float** %5
store float* %13, float** %10
%14 = load float*, float** %10
%15 = getelementptr inbounds float, float* %14, i32 1
store float* %15, float** %10
%16 = load float, float* %14
store float %16, float* %7
store float 0.000000e+00, float* %8
%17 = load i32, i32* %6
%18 = sub nsw i32 %17, 1
store i32 %18, i32* %11
br label %19
19: ; preds = %31, %3
%20 = load float, float* %8
store float %20, float* %9
%21 = load float, float* %7
store float %21, float* %8
%22 = load float, float* %4
%23 = load float, float* %8
%24 = load float, float* %9
%25 = fneg float %24
%26 = call float @llvm.fmuladd.f32(float %22, float %23, float %25)
%27 = load float*, float** %10
%28 = getelementptr inbounds float, float* %27, i32 1
store float* %28, float** %10
%29 = load float, float* %27
%30 = fadd float %26, %29
store float %30, float* %7
br label %31
31: ; preds = %19
%32 = load i32, i32* %11
%33 = add nsw i32 %32, -1
store i32 %33, i32* %11
%34 = icmp ne i32 %33, 0
br i1 %34, label %19, label %35
35: ; preds = %31
%36 = load float, float* %7
%37 = load float, float* %9
%38 = fsub float %36, %37
%39 = fpext float %38 to double
%40 = fmul double 5.000000e-01, %39
%41 = fptrunc double %40 to float
ret float %41
}

LLVM IR (-O2):
define float @chbevlf(double %0, float* nocapture %1, i32 %2) {
%4 = fptrunc double %0 to float
%5 = load float, float* %1
%6 = add i32 %2, -1
%7 = add i32 %2, -2
%8 = and i32 %6, 3
%9 = icmp eq i32 %8, 0
br i1 %9, label %24, label %10
10: ; preds = %3, %10
%11 = phi float [ %12, %10 ], [ 0.000000e+00, %3 ]
%12 = phi float [ %20, %10 ], [ %5, %3 ]
%13 = phi float* [ %16, %10 ], [ %1, %3 ]
%14 = phi i32 [ %21, %10 ], [ %6, %3 ]
%15 = phi i32 [ %22, %10 ], [ 0, %3 ]
%16 = getelementptr inbounds float, float* %13, i64 1
%17 = fneg float %11
%18 = tail call float @llvm.fmuladd.f32(float %4, float %12, float %17)
%19 = load float, float* %16
%20 = fadd float %18, %19
%21 = add nsw i32 %14, -1
%22 = add i32 %15, 1
%23 = icmp eq i32 %22, %8
br i1 %23, label %24, label %10
24: ; preds = %10, %3
%25 = phi float [ undef, %3 ], [ %11, %10 ]
%26 = phi float [ undef, %3 ], [ %20, %10 ]
%27 = phi float [ 0.000000e+00, %3 ], [ %12, %10 ]
%28 = phi float [ %5, %3 ], [ %20, %10 ]
%29 = phi float* [ %1, %3 ], [ %16, %10 ]
%30 = phi i32 [ %6, %3 ], [ %21, %10 ]
%31 = icmp ult i32 %7, 3
br i1 %31, label %59, label %32
32: ; preds = %24, %32
%33 = phi float [ %51, %32 ], [ %27, %24 ]
%34 = phi float [ %56, %32 ], [ %28, %24 ]
%35 = phi float* [ %52, %32 ], [ %29, %24 ]
%36 = phi i32 [ %57, %32 ], [ %30, %24 ]
%37 = getelementptr inbounds float, float* %35, i64 1
%38 = fneg float %33
%39 = tail call float @llvm.fmuladd.f32(float %4, float %34, float %38)
%40 = load float, float* %37
%41 = fadd float %39, %40
%42 = getelementptr inbounds float, float* %35, i64 2
%43 = fneg float %34
%44 = tail call float @llvm.fmuladd.f32(float %4, float %41, float %43)
%45 = load float, float* %42
%46 = fadd float %44, %45
%47 = getelementptr inbounds float, float* %35, i64 3
%48 = fneg float %41
%49 = tail call float @llvm.fmuladd.f32(float %4, float %46, float %48)
%50 = load float, float* %47
%51 = fadd float %49, %50
%52 = getelementptr inbounds float, float* %35, i64 4
%53 = fneg float %46
%54 = tail call float @llvm.fmuladd.f32(float %4, float %51, float %53)
%55 = load float, float* %52
%56 = fadd float %54, %55
%57 = add nsw i32 %36, -4
%58 = icmp eq i32 %57, 0
br i1 %58, label %59, label %32
59: ; preds = %32, %24
%60 = phi float [ %25, %24 ], [ %46, %32 ]
%61 = phi float [ %26, %24 ], [ %56, %32 ]
%62 = fsub float %61, %60
%63 = fmul float %62, 5.000000e-01
ret float %63
}