double glsadff1t(double x, double *c, const int m, const double g, double *d) {
  int i;
  x -= d[0] * g;
  d[m] = c[m] * x;
  for (i = m - 1; i >= 1; i--)
    d[i] += c[i] * x;
  for (i = 0; i < m; i++)
    d[i] = d[i + 1];
  return (x);
}


x86 assembly (clang, -O0):
<glsadff1t>:
push   %rbp
mov    %rsp,%rbp
movsd  %xmm0,-0x8(%rbp)
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
movsd  %xmm1,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x20(%rbp),%xmm2
movsd  -0x8(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x8(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x8(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x1,-0x2c(%rbp)
jl     11bb <glsadff1t+0xbb>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x8(%rbp),%xmm2
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    1177 <glsadff1t+0x77>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11fb <glsadff1t+0xfb>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11c2 <glsadff1t+0xc2>
movsd  -0x8(%rbp),%xmm0
pop    %rbp
ret

x86 assembly (clang, -O2):
<glsadff1t>:
push   %rbx
sub    $0x10,%rsp
mulsd  (%rdx),%xmm1
subsd  %xmm1,%xmm0
movslq %esi,%rax
movsd  (%rdi,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rdx,%rax,8)
mov    %esi,%r10d
cmp    $0x2,%eax
jl     11e0 <glsadff1t+0xd0>
xor    %r9d,%r9d
mov    %r10,%rcx
sub    $0x2,%rcx
mov    $0x0,%r8d
cmovae %rcx,%r8
add    $0x1,%r8
mov    %r10,%rax
cmp    $0x4,%r8
jb     11b9 <glsadff1t+0xa9>
sub    $0x2,%rax
mov    $0x0,%ecx
cmovae %rax,%rcx
mov    %r10d,%eax
sub    $0x2,%eax
cmovb  %r9d,%eax
lea    -0x1(%rsi),%r9d
cmp    %eax,%r9d
jb     11b6 <glsadff1t+0xa6>
shr    $0x20,%rcx
jne    11b6 <glsadff1t+0xa6>
cmp    $0x2,%r10
mov    $0x2,%ecx
cmovb  %r10,%rcx
add    %r9,%rcx
sub    %r10,%rcx
lea    (%rdx,%rcx,8),%r11
lea    (%rdi,%r9,8),%rax
add    $0x8,%rax
cmp    %rax,%r11
jae    1207 <glsadff1t+0xf7>
lea    (%rdx,%r9,8),%rax
add    $0x8,%rax
lea    (%rdi,%rcx,8),%rcx
cmp    %rax,%rcx
jae    1207 <glsadff1t+0xf7>
mov    %r10,%rax
add    $0x1,%rax
nopl   (%rax)
lea    -0x2(%rax),%ecx
movsd  (%rdi,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdx,%rcx,8),%xmm1
movsd  %xmm1,(%rdx,%rcx,8)
add    $0xffffffffffffffff,%rax
cmp    $0x2,%rax
ja     11c0 <glsadff1t+0xb0>
test   %esi,%esi
jle    1201 <glsadff1t+0xf1>
lea    0x8(%rdx),%rsi
shl    $0x3,%r10
mov    %rdx,%rdi
mov    %r10,%rdx
movapd %xmm0,(%rsp)
call   1030 <memmove@plt>
movapd (%rsp),%xmm0
add    $0x10,%rsp
pop    %rbx
ret
mov    %r8,%r9
and    $0xfffffffffffffffc,%r9
mov    %r10,%rax
sub    %r9,%rax
movapd %xmm0,%xmm5
unpcklpd %xmm0,%xmm5
lea    -0x1(%r10),%rcx
shufpd $0x1,%xmm5,%xmm5
mov    %r9,%r11
nopl   0x0(%rax,%rax,1)
mov    %ecx,%ebx
shl    $0x3,%rbx
movupd -0x18(%rdi,%rbx,1),%xmm1
movupd -0x8(%rdi,%rbx,1),%xmm2
movupd -0x18(%rdx,%rbx,1),%xmm3
movupd -0x8(%rdx,%rbx,1),%xmm4
mulpd  %xmm5,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm2,-0x8(%rdx,%rbx,1)
mulpd  %xmm5,%xmm1
addpd  %xmm3,%xmm1
movupd %xmm1,-0x18(%rdx,%rbx,1)
add    $0xfffffffffffffffc,%rcx
add    $0xfffffffffffffffc,%r11
jne    1230 <glsadff1t+0x120>
cmp    %r9,%r8
je     11e0 <glsadff1t+0xd0>
jmp    11b9 <glsadff1t+0xa9>

LLVM IR (-O0):
define double @glsadff1t(double %0, double* %1, i32 %2, double %3, double* %4) {
%6 = alloca double
%7 = alloca double*
%8 = alloca i32
%9 = alloca double
%10 = alloca double*
%11 = alloca i32
store double %0, double* %6
store double* %1, double** %7
store i32 %2, i32* %8
store double %3, double* %9
store double* %4, double** %10
%12 = load double*, double** %10
%13 = getelementptr inbounds double, double* %12, i64 0
%14 = load double, double* %13
%15 = load double, double* %9
%16 = load double, double* %6
%17 = fneg double %14
%18 = call double @llvm.fmuladd.f64(double %17, double %15, double %16)
store double %18, double* %6
%19 = load double*, double** %7
%20 = load i32, i32* %8
%21 = sext i32 %20 to i64
%22 = getelementptr inbounds double, double* %19, i64 %21
%23 = load double, double* %22
%24 = load double, double* %6
%25 = fmul double %23, %24
%26 = load double*, double** %10
%27 = load i32, i32* %8
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds double, double* %26, i64 %28
store double %25, double* %29
%30 = load i32, i32* %8
%31 = sub nsw i32 %30, 1
store i32 %31, i32* %11
br label %32
32: ; preds = %48, %5
%33 = load i32, i32* %11
%34 = icmp sge i32 %33, 1
br i1 %34, label %35, label %51
35: ; preds = %32
%36 = load double*, double** %7
%37 = load i32, i32* %11
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds double, double* %36, i64 %38
%40 = load double, double* %39
%41 = load double, double* %6
%42 = load double*, double** %10
%43 = load i32, i32* %11
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds double, double* %42, i64 %44
%46 = load double, double* %45
%47 = call double @llvm.fmuladd.f64(double %40, double %41, double %46)
store double %47, double* %45
br label %48
48: ; preds = %35
%49 = load i32, i32* %11
%50 = add nsw i32 %49, -1
store i32 %50, i32* %11
br label %32
51: ; preds = %32
store i32 0, i32* %11
br label %52
52: ; preds = %67, %51
%53 = load i32, i32* %11
%54 = load i32, i32* %8
%55 = icmp slt i32 %53, %54
br i1 %55, label %56, label %70
56: ; preds = %52
%57 = load double*, double** %10
%58 = load i32, i32* %11
%59 = add nsw i32 %58, 1
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds double, double* %57, i64 %60
%62 = load double, double* %61
%63 = load double*, double** %10
%64 = load i32, i32* %11
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds double, double* %63, i64 %65
store double %62, double* %66
br label %67
67: ; preds = %56
%68 = load i32, i32* %11
%69 = add nsw i32 %68, 1
store i32 %69, i32* %11
br label %52
70: ; preds = %52
%71 = load double, double* %6
ret double %71
}

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