void shift_up(float *dat, int w, int h, int dn, double a, double b) {
  int x, y;
  float *dp, *sp1, *sp2;
  dp = dat;
  sp1 = dat + w * (dn);
  sp2 = dat + w * (dn + 1);
  for (y = 0; y < h - dn - 1; y++) {
    for (x = 0; x < w; x++) {
      *dp = *sp1 * b + *sp2 * a;
      dp++;
      sp1++;
      sp2++;
    }
  }
  for (x = 0; x < w; x++) {
    *dp = *sp1 * b;
    dp++;
    sp1++;
  }
  for (y = 0; y < dn; y++)
    for (x = 0; x < w; x++)
      *dp-- = 0.0;
}


x86 assembly (clang, -O0):
<shift_up>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
movsd  %xmm0,-0x20(%rbp)
movsd  %xmm1,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1203 <shift_up+0x103>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11f0 <shift_up+0xf0>
mov    -0x40(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  -0x28(%rbp),%xmm2
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  -0x20(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x38(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x38(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x40(%rbp)
mov    -0x48(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x48(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    117c <shift_up+0x7c>
jmp    11f5 <shift_up+0xf5>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1161 <shift_up+0x61>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1259 <shift_up+0x159>
mov    -0x40(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  -0x28(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x38(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x38(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x40(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    120a <shift_up+0x10a>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12b6 <shift_up+0x1b6>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12a3 <shift_up+0x1a3>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x38(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1273 <shift_up+0x173>
jmp    12a8 <shift_up+0x1a8>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1260 <shift_up+0x160>
pop    %rbp
ret

x86 assembly (clang, -O2):
<shift_up>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %rdi,%rbx
mov    %ecx,%eax
imul   %esi,%eax
cltq
lea    (%rdi,%rax,4),%rax
mov    %ecx,%r9d
not    %r9d
add    %edx,%r9d
test   %r9d,%r9d
mov    %rsi,0x8(%rsp)
mov    %rcx,0x18(%rsp)
jle    13f4 <shift_up+0x2e4>
add    $0x1,%ecx
imul   %esi,%ecx
movslq %ecx,%rcx
lea    (%rbx,%rcx,4),%rdx
lea    -0x1(%rsi),%r8d
lea    0x1(%r8),%r13
mov    %r13,%r15
and    $0xfffffffffffffffc,%r15
lea    -0x4(%r15),%rcx
mov    %rcx,0x30(%rsp)
mov    %rcx,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
movapd %xmm1,%xmm3
unpcklpd %xmm1,%xmm3
mov    %rdi,%rcx
mov    %rdi,0x28(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0x20(%rsp)
mov    %esi,%ecx
neg    %ecx
mov    %ecx,0x14(%rsp)
xor    %r14d,%r14d
jmp    11bd <shift_up+0xad>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r14d
cmp    %r9d,%r14d
je     13f4 <shift_up+0x2e4>
test   %esi,%esi
jle    11b0 <shift_up+0xa0>
xor    %ebp,%ebp
cmp    $0x3,%r8d
jb     1308 <shift_up+0x1f8>
lea    (%rbx,%r13,4),%rdi
lea    (%rax,%r13,4),%rcx
lea    (%rdx,%r13,4),%r11
cmp    %rcx,%rbx
setb   %r10b
cmp    %rdi,%rax
setb   %r12b
cmp    %r11,%rbx
setb   %cl
cmp    %rdi,%rdx
setb   %dil
test   %r12b,%r10b
jne    1303 <shift_up+0x1f3>
and    %dil,%cl
jne    1303 <shift_up+0x1f3>
cmpq   $0x0,0x30(%rsp)
mov    0x8(%rsp),%rsi
je     13e2 <shift_up+0x2d2>
mov    0x20(%rsp),%rdi
xor    %ecx,%ecx
xchg   %ax,%ax
cvtps2pd 0x8(%rax,%rcx,4),%xmm4
cvtps2pd (%rax,%rcx,4),%xmm5
cvtps2pd (%rdx,%rcx,4),%xmm6
cvtps2pd 0x8(%rdx,%rcx,4),%xmm7
mulpd  %xmm2,%xmm7
mulpd  %xmm2,%xmm6
mulpd  %xmm3,%xmm5
addpd  %xmm6,%xmm5
mulpd  %xmm3,%xmm4
addpd  %xmm7,%xmm4
cvtpd2ps %xmm4,%xmm4
cvtpd2ps %xmm5,%xmm5
unpcklpd %xmm4,%xmm5
movupd %xmm5,(%rbx,%rcx,4)
cvtps2pd 0x18(%rax,%rcx,4),%xmm4
cvtps2pd 0x10(%rax,%rcx,4),%xmm5
cvtps2pd 0x10(%rdx,%rcx,4),%xmm6
cvtps2pd 0x18(%rdx,%rcx,4),%xmm7
mulpd  %xmm2,%xmm7
mulpd  %xmm2,%xmm6
mulpd  %xmm3,%xmm5
addpd  %xmm6,%xmm5
mulpd  %xmm3,%xmm4
addpd  %xmm7,%xmm4
cvtpd2ps %xmm4,%xmm4
cvtpd2ps %xmm5,%xmm5
unpcklpd %xmm4,%xmm5
movupd %xmm5,0x10(%rbx,%rcx,4)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdi
jne    1220 <shift_up+0x110>
testb  $0x1,0x28(%rsp)
je     12e9 <shift_up+0x1d9>
cvtps2pd 0x8(%rax,%rcx,4),%xmm4
cvtps2pd (%rax,%rcx,4),%xmm5
cvtps2pd (%rdx,%rcx,4),%xmm6
cvtps2pd 0x8(%rdx,%rcx,4),%xmm7
mulpd  %xmm2,%xmm7
mulpd  %xmm2,%xmm6
mulpd  %xmm3,%xmm5
addpd  %xmm6,%xmm5
mulpd  %xmm3,%xmm4
addpd  %xmm7,%xmm4
cvtpd2ps %xmm4,%xmm4
cvtpd2ps %xmm5,%xmm5
unpcklpd %xmm4,%xmm5
movupd %xmm5,(%rbx,%rcx,4)
lea    (%rdx,%r15,4),%rdx
lea    (%rax,%r15,4),%rax
lea    (%rbx,%r15,4),%rbx
mov    %r15d,%ebp
cmp    %r15,%r13
je     11b0 <shift_up+0xa0>
jmp    1308 <shift_up+0x1f8>
mov    0x8(%rsp),%rsi
mov    %esi,%ecx
sub    %ebp,%ecx
test   $0x1,%cl
jne    1320 <shift_up+0x210>
mov    %ebp,%ecx
jmp    1353 <shift_up+0x243>
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rax),%xmm4
cvtss2sd %xmm4,%xmm4
movss  (%rdx),%xmm5
cvtss2sd %xmm5,%xmm5
mulsd  %xmm0,%xmm5
mulsd  %xmm1,%xmm4
addsd  %xmm5,%xmm4
cvtsd2ss %xmm4,%xmm4
movss  %xmm4,(%rbx)
add    $0x4,%rbx
add    $0x4,%rax
add    $0x4,%rdx
lea    0x1(%rbp),%ecx
not    %ebp
cmp    0x14(%rsp),%ebp
je     11b0 <shift_up+0xa0>
mov    %esi,%edi
sub    %ecx,%edi
xor    %r11d,%r11d
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movss  (%rax,%r11,4),%xmm4
cvtss2sd %xmm4,%xmm4
movss  (%rdx,%r11,4),%xmm5
cvtss2sd %xmm5,%xmm5
mulsd  %xmm0,%xmm5
mulsd  %xmm1,%xmm4
addsd  %xmm5,%xmm4
cvtsd2ss %xmm4,%xmm4
movss  %xmm4,(%rbx,%r11,4)
movss  0x4(%rax,%r11,4),%xmm4
cvtss2sd %xmm4,%xmm4
movss  0x4(%rdx,%r11,4),%xmm5
cvtss2sd %xmm5,%xmm5
mulsd  %xmm0,%xmm5
mulsd  %xmm1,%xmm4
addsd  %xmm5,%xmm4
cvtsd2ss %xmm4,%xmm4
movss  %xmm4,0x4(%rbx,%r11,4)
add    $0xfffffffffffffff8,%rcx
add    $0x2,%r11
cmp    %r11d,%edi
jne    1370 <shift_up+0x260>
sub    %rcx,%rdx
sub    %rcx,%rax
sub    %rcx,%rbx
jmp    11b0 <shift_up+0xa0>
xor    %ecx,%ecx
testb  $0x1,0x28(%rsp)
jne    12ae <shift_up+0x19e>
jmp    12e9 <shift_up+0x1d9>
test   %esi,%esi
jle    1616 <shift_up+0x506>
lea    -0x1(%rsi),%edx
xor    %ecx,%ecx
cmp    $0x7,%edx
jb     1569 <shift_up+0x459>
lea    (%rax,%rdx,4),%rdi
add    $0x4,%rdi
cmp    %rdi,%rbx
jae    1428 <shift_up+0x318>
lea    (%rbx,%rdx,4),%rdi
add    $0x4,%rdi
cmp    %rdi,%rax
jb     1569 <shift_up+0x459>
add    $0x1,%rdx
movabs $0x1fffffffc,%rcx
add    $0xfffffffffffffffc,%rcx
and    %rdx,%rcx
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
lea    -0x8(%rcx),%rdi
mov    %rdi,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rdi,%rdi
je     1704 <shift_up+0x5f4>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
cvtps2pd 0x8(%rax,%rbp,4),%xmm2
cvtps2pd (%rax,%rbp,4),%xmm3
cvtps2pd 0x18(%rax,%rbp,4),%xmm4
cvtps2pd 0x10(%rax,%rbp,4),%xmm5
mulpd  %xmm0,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm5
mulpd  %xmm0,%xmm4
cvtpd2ps %xmm2,%xmm2
cvtpd2ps %xmm3,%xmm3
cvtpd2ps %xmm4,%xmm4
unpcklpd %xmm2,%xmm3
cvtpd2ps %xmm5,%xmm2
unpcklpd %xmm4,%xmm2
movupd %xmm3,(%rbx,%rbp,4)
movupd %xmm2,0x10(%rbx,%rbp,4)
cvtps2pd 0x28(%rax,%rbp,4),%xmm2
cvtps2pd 0x20(%rax,%rbp,4),%xmm3
cvtps2pd 0x38(%rax,%rbp,4),%xmm4
cvtps2pd 0x30(%rax,%rbp,4),%xmm5
mulpd  %xmm0,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm5
mulpd  %xmm0,%xmm4
cvtpd2ps %xmm2,%xmm2
cvtpd2ps %xmm3,%xmm3
cvtpd2ps %xmm4,%xmm4
unpcklpd %xmm2,%xmm3
cvtpd2ps %xmm5,%xmm2
unpcklpd %xmm4,%xmm2
movupd %xmm3,0x20(%rbx,%rbp,4)
movupd %xmm2,0x30(%rbx,%rbp,4)
add    $0x10,%rbp
add    $0xfffffffffffffffe,%rdi
jne    1470 <shift_up+0x360>
test   $0x1,%r8b
je     1558 <shift_up+0x448>
cvtps2pd 0x8(%rax,%rbp,4),%xmm2
cvtps2pd (%rax,%rbp,4),%xmm3
cvtps2pd 0x18(%rax,%rbp,4),%xmm4
cvtps2pd 0x10(%rax,%rbp,4),%xmm5
mulpd  %xmm0,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm5
mulpd  %xmm0,%xmm4
cvtpd2ps %xmm2,%xmm0
cvtpd2ps %xmm3,%xmm2
cvtpd2ps %xmm4,%xmm3
cvtpd2ps %xmm5,%xmm4
unpcklpd %xmm0,%xmm2
unpcklpd %xmm3,%xmm4
movupd %xmm2,(%rbx,%rbp,4)
movupd %xmm4,0x10(%rbx,%rbp,4)
lea    (%rbx,%rcx,4),%rbx
cmp    %rcx,%rdx
je     1616 <shift_up+0x506>
lea    (%rax,%rcx,4),%rax
mov    %esi,%ebp
sub    %ecx,%ebp
mov    %ecx,%edx
not    %edx
add    %esi,%edx
and    $0x3,%ebp
je     15a5 <shift_up+0x495>
neg    %ebp
xor    %edi,%edi
nopl   0x0(%rax)
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rbx)
add    $0x4,%rbx
add    $0x4,%rax
add    $0xffffffff,%edi
cmp    %edi,%ebp
jne    1580 <shift_up+0x470>
sub    %edi,%ecx
cmp    $0x3,%edx
jb     1616 <shift_up+0x506>
mov    %esi,%edx
sub    %ecx,%edx
xor    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rbx)
movss  0x4(%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x4(%rbx)
movss  0x8(%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x8(%rbx)
movss  0xc(%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0xc(%rbx)
add    $0x10,%rbx
add    $0x4,%rcx
cmp    %ecx,%edx
jne    15b0 <shift_up+0x4a0>
mov    0x18(%rsp),%r14
test   %r14d,%r14d
jle    1648 <shift_up+0x538>
lea    -0x1(%rsi),%ebp
mov    %rbp,%r13
neg    %r13
mov    %esi,%r12d
shl    $0x2,%r12
not    %rbp
lea    -0x1(%r14),%eax
mov    %r14d,%r15d
and    $0x3,%r15d
cmp    $0x3,%eax
jae    1683 <shift_up+0x573>
test   %r15d,%r15d
jne    1666 <shift_up+0x556>
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
nopw   0x0(%rax,%rax,1)
add    $0xffffffff,%r15d
je     1648 <shift_up+0x538>
test   %esi,%esi
jle    1660 <shift_up+0x550>
lea    (%rbx,%r13,4),%rdi
xor    %esi,%esi
mov    %r12,%rdx
call   1030 <memset@plt>
mov    0x8(%rsp),%rsi
lea    (%rbx,%rbp,4),%rbx
jmp    1660 <shift_up+0x550>
and    $0xfffffffc,%r14d
jmp    1696 <shift_up+0x586>
nopl   0x0(%rax)
add    $0xfffffffc,%r14d
je     1643 <shift_up+0x533>
test   %esi,%esi
jle    16b1 <shift_up+0x5a1>
lea    (%rbx,%r13,4),%rdi
xor    %esi,%esi
mov    %r12,%rdx
call   1030 <memset@plt>
mov    0x8(%rsp),%rsi
lea    (%rbx,%rbp,4),%rbx
test   %esi,%esi
jle    16cc <shift_up+0x5bc>
lea    (%rbx,%r13,4),%rdi
xor    %esi,%esi
mov    %r12,%rdx
call   1030 <memset@plt>
mov    0x8(%rsp),%rsi
lea    (%rbx,%rbp,4),%rbx
test   %esi,%esi
jle    16e7 <shift_up+0x5d7>
lea    (%rbx,%r13,4),%rdi
xor    %esi,%esi
mov    %r12,%rdx
call   1030 <memset@plt>
mov    0x8(%rsp),%rsi
lea    (%rbx,%rbp,4),%rbx
test   %esi,%esi
jle    1690 <shift_up+0x580>
lea    (%rbx,%r13,4),%rdi
xor    %esi,%esi
mov    %r12,%rdx
call   1030 <memset@plt>
mov    0x8(%rsp),%rsi
lea    (%rbx,%rbp,4),%rbx
jmp    1690 <shift_up+0x580>
xor    %ebp,%ebp
test   $0x1,%r8b
jne    1512 <shift_up+0x402>
jmp    1558 <shift_up+0x448>

LLVM IR (-O0):
define void @shift_up(float* %0, i32 %1, i32 %2, i32 %3, double %4, double %5) {
%7 = alloca float*
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca double
%12 = alloca double
%13 = alloca i32
%14 = alloca i32
%15 = alloca float*
%16 = alloca float*
%17 = alloca float*
store float* %0, float** %7
store i32 %1, i32* %8
store i32 %2, i32* %9
store i32 %3, i32* %10
store double %4, double* %11
store double %5, double* %12
%18 = load float*, float** %7
store float* %18, float** %15
%19 = load float*, float** %7
%20 = load i32, i32* %8
%21 = load i32, i32* %10
%22 = mul nsw i32 %20, %21
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds float, float* %19, i64 %23
store float* %24, float** %16
%25 = load float*, float** %7
%26 = load i32, i32* %8
%27 = load i32, i32* %10
%28 = add nsw i32 %27, 1
%29 = mul nsw i32 %26, %28
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds float, float* %25, i64 %30
store float* %31, float** %17
store i32 0, i32* %14
br label %32
32: ; preds = %67, %6
%33 = load i32, i32* %14
%34 = load i32, i32* %9
%35 = load i32, i32* %10
%36 = sub nsw i32 %34, %35
%37 = sub nsw i32 %36, 1
%38 = icmp slt i32 %33, %37
br i1 %38, label %39, label %70
39: ; preds = %32
store i32 0, i32* %13
br label %40
40: ; preds = %63, %39
%41 = load i32, i32* %13
%42 = load i32, i32* %8
%43 = icmp slt i32 %41, %42
br i1 %43, label %44, label %66
44: ; preds = %40
%45 = load float*, float** %16
%46 = load float, float* %45
%47 = fpext float %46 to double
%48 = load double, double* %12
%49 = load float*, float** %17
%50 = load float, float* %49
%51 = fpext float %50 to double
%52 = load double, double* %11
%53 = fmul double %51, %52
%54 = call double @llvm.fmuladd.f64(double %47, double %48, double %53)
%55 = fptrunc double %54 to float
%56 = load float*, float** %15
store float %55, float* %56
%57 = load float*, float** %15
%58 = getelementptr inbounds float, float* %57, i32 1
store float* %58, float** %15
%59 = load float*, float** %16
%60 = getelementptr inbounds float, float* %59, i32 1
store float* %60, float** %16
%61 = load float*, float** %17
%62 = getelementptr inbounds float, float* %61, i32 1
store float* %62, float** %17
br label %63
63: ; preds = %44
%64 = load i32, i32* %13
%65 = add nsw i32 %64, 1
store i32 %65, i32* %13
br label %40
66: ; preds = %40
br label %67
67: ; preds = %66
%68 = load i32, i32* %14
%69 = add nsw i32 %68, 1
store i32 %69, i32* %14
br label %32
70: ; preds = %32
store i32 0, i32* %13
br label %71
71: ; preds = %87, %70
%72 = load i32, i32* %13
%73 = load i32, i32* %8
%74 = icmp slt i32 %72, %73
br i1 %74, label %75, label %90
75: ; preds = %71
%76 = load float*, float** %16
%77 = load float, float* %76
%78 = fpext float %77 to double
%79 = load double, double* %12
%80 = fmul double %78, %79
%81 = fptrunc double %80 to float
%82 = load float*, float** %15
store float %81, float* %82
%83 = load float*, float** %15
%84 = getelementptr inbounds float, float* %83, i32 1
store float* %84, float** %15
%85 = load float*, float** %16
%86 = getelementptr inbounds float, float* %85, i32 1
store float* %86, float** %16
br label %87
87: ; preds = %75
%88 = load i32, i32* %13
%89 = add nsw i32 %88, 1
store i32 %89, i32* %13
br label %71
90: ; preds = %71
store i32 0, i32* %14
br label %91
91: ; preds = %107, %90
%92 = load i32, i32* %14
%93 = load i32, i32* %10
%94 = icmp slt i32 %92, %93
br i1 %94, label %95, label %110
95: ; preds = %91
store i32 0, i32* %13
br label %96
96: ; preds = %103, %95
%97 = load i32, i32* %13
%98 = load i32, i32* %8
%99 = icmp slt i32 %97, %98
br i1 %99, label %100, label %106
100: ; preds = %96
%101 = load float*, float** %15
%102 = getelementptr inbounds float, float* %101, i32 -1
store float* %102, float** %15
store float 0.000000e+00, float* %101
br label %103
103: ; preds = %100
%104 = load i32, i32* %13
%105 = add nsw i32 %104, 1
store i32 %105, i32* %13
br label %96
106: ; preds = %96
br label %107
107: ; preds = %106
%108 = load i32, i32* %14
%109 = add nsw i32 %108, 1
store i32 %109, i32* %14
br label %91
110: ; preds = %91
ret void
}

LLVM IR (-O2):
define void @shift_up(float* nocapture %0, i32 %1, i32 %2, i32 %3, double %4, double %5) {
%7 = mul nsw i32 %3, %1
%8 = sext i32 %7 to i64
%9 = getelementptr inbounds float, float* %0, i64 %8
%10 = xor i32 %3, -1
%11 = add i32 %10, %2
%12 = icmp sgt i32 %11, 0
br i1 %12, label %13, label %142
13: ; preds = %6
%14 = add nsw i32 %3, 1
%15 = mul nsw i32 %14, %1
%16 = sext i32 %15 to i64
%17 = getelementptr inbounds float, float* %0, i64 %16
%18 = icmp sgt i32 %1, 0
%19 = add i32 %1, -1
%20 = zext i32 %19 to i64
%21 = add nuw nsw i64 %20, 1
%22 = zext i32 %19 to i64
%23 = add nuw nsw i64 %22, 1
%24 = and i64 %23, 8589934588
%25 = add nsw i64 %24, -4
%26 = lshr exact i64 %25, 2
%27 = add nuw nsw i64 %26, 1
%28 = icmp ult i32 %19, 3
%29 = and i64 %23, 8589934588
%30 = trunc i64 %29 to i32
%31 = insertelement <4 x double> poison, double %4, i64 0
%32 = shufflevector <4 x double> %31, <4 x double> poison, <4 x i32> zeroinitializer
%33 = insertelement <4 x double> poison, double %5, i64 0
%34 = shufflevector <4 x double> %33, <4 x double> poison, <4 x i32> zeroinitializer
%35 = and i64 %27, 1
%36 = icmp eq i64 %25, 0
%37 = and i64 %27, 9223372036854775806
%38 = icmp eq i64 %35, 0
%39 = icmp eq i64 %23, %29
%40 = sub i32 0, %1
br label %41
41: ; preds = %13, %293
%42 = phi float* [ %17, %13 ], [ %296, %293 ]
%43 = phi float* [ %9, %13 ], [ %295, %293 ]
%44 = phi float* [ %0, %13 ], [ %294, %293 ]
%45 = phi i32 [ 0, %13 ], [ %297, %293 ]
br i1 %18, label %46, label %293
46: ; preds = %41
br i1 %28, label %112, label %47
47: ; preds = %46
%48 = getelementptr float, float* %44, i64 %21
%49 = getelementptr float, float* %43, i64 %21
%50 = getelementptr float, float* %42, i64 %21
%51 = icmp ult float* %44, %49
%52 = icmp ult float* %43, %48
%53 = and i1 %51, %52
%54 = icmp ult float* %44, %50
%55 = icmp ult float* %42, %48
%56 = and i1 %54, %55
%57 = or i1 %53, %56
br i1 %57, label %112, label %58
58: ; preds = %47
%59 = getelementptr float, float* %42, i64 %29
%60 = getelementptr float, float* %43, i64 %29
%61 = getelementptr float, float* %44, i64 %29
br i1 %36, label %95, label %62
62: ; preds = %58, %62
%63 = phi i64 [ %92, %62 ], [ 0, %58 ]
%64 = phi i64 [ %93, %62 ], [ 0, %58 ]
%65 = getelementptr float, float* %42, i64 %63
%66 = getelementptr float, float* %43, i64 %63
%67 = getelementptr float, float* %44, i64 %63
%68 = bitcast float* %66 to <4 x float>*
%69 = load <4 x float>, <4 x float>* %68
%70 = fpext <4 x float> %69 to <4 x double>
%71 = bitcast float* %65 to <4 x float>*
%72 = load <4 x float>, <4 x float>* %71
%73 = fpext <4 x float> %72 to <4 x double>
%74 = fmul <4 x double> %32, %73
%75 = call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %70, <4 x double> %34, <4 x double> %74)
%76 = fptrunc <4 x double> %75 to <4 x float>
%77 = bitcast float* %67 to <4 x float>*
store <4 x float> %76, <4 x float>* %77
%78 = or i64 %63, 4
%79 = getelementptr float, float* %42, i64 %78
%80 = getelementptr float, float* %43, i64 %78
%81 = getelementptr float, float* %44, i64 %78
%82 = bitcast float* %80 to <4 x float>*
%83 = load <4 x float>, <4 x float>* %82
%84 = fpext <4 x float> %83 to <4 x double>
%85 = bitcast float* %79 to <4 x float>*
%86 = load <4 x float>, <4 x float>* %85
%87 = fpext <4 x float> %86 to <4 x double>
%88 = fmul <4 x double> %32, %87
%89 = call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %84, <4 x double> %34, <4 x double> %88)
%90 = fptrunc <4 x double> %89 to <4 x float>
%91 = bitcast float* %81 to <4 x float>*
store <4 x float> %90, <4 x float>* %91
%92 = add nuw i64 %63, 8
%93 = add i64 %64, 2
%94 = icmp eq i64 %93, %37
br i1 %94, label %95, label %62
95: ; preds = %62, %58
%96 = phi i64 [ 0, %58 ], [ %92, %62 ]
br i1 %38, label %111, label %97
97: ; preds = %95
%98 = getelementptr float, float* %42, i64 %96
%99 = getelementptr float, float* %43, i64 %96
%100 = getelementptr float, float* %44, i64 %96
%101 = bitcast float* %99 to <4 x float>*
%102 = load <4 x float>, <4 x float>* %101
%103 = fpext <4 x float> %102 to <4 x double>
%104 = bitcast float* %98 to <4 x float>*
%105 = load <4 x float>, <4 x float>* %104
%106 = fpext <4 x float> %105 to <4 x double>
%107 = fmul <4 x double> %32, %106
%108 = call <4 x double> @llvm.fmuladd.v4f64(<4 x double> %103, <4 x double> %34, <4 x double> %107)
%109 = fptrunc <4 x double> %108 to <4 x float>
%110 = bitcast float* %100 to <4 x float>*
store <4 x float> %109, <4 x float>* %110
br label %111
111: ; preds = %95, %97
br i1 %39, label %293, label %112
112: ; preds = %47, %46, %111
%113 = phi float* [ %42, %47 ], [ %42, %46 ], [ %59, %111 ]
%114 = phi float* [ %43, %47 ], [ %43, %46 ], [ %60, %111 ]
%115 = phi float* [ %44, %47 ], [ %44, %46 ], [ %61, %111 ]
%116 = phi i32 [ 0, %47 ], [ 0, %46 ], [ %30, %111 ]
%117 = sub i32 %1, %116
%118 = xor i32 %116, -1
%119 = and i32 %117, 1
%120 = icmp eq i32 %119, 0
br i1 %120, label %133, label %121
121: ; preds = %112
%122 = load float, float* %114
%123 = fpext float %122 to double
%124 = load float, float* %113
%125 = fpext float %124 to double
%126 = fmul double %125, %4
%127 = tail call double @llvm.fmuladd.f64(double %123, double %5, double %126)
%128 = fptrunc double %127 to float
store float %128, float* %115
%129 = getelementptr inbounds float, float* %115, i64 1
%130 = getelementptr inbounds float, float* %114, i64 1
%131 = getelementptr inbounds float, float* %113, i64 1
%132 = add nuw nsw i32 %116, 1
br label %133
133: ; preds = %121, %112
%134 = phi float* [ undef, %112 ], [ %129, %121 ]
%135 = phi float* [ undef, %112 ], [ %130, %121 ]
%136 = phi float* [ undef, %112 ], [ %131, %121 ]
%137 = phi float* [ %113, %112 ], [ %131, %121 ]
%138 = phi float* [ %114, %112 ], [ %130, %121 ]
%139 = phi float* [ %115, %112 ], [ %129, %121 ]
%140 = phi i32 [ %116, %112 ], [ %132, %121 ]
%141 = icmp eq i32 %118, %40
br i1 %141, label %293, label %266
142: ; preds = %293, %6
%143 = phi float* [ %0, %6 ], [ %294, %293 ]
%144 = phi float* [ %9, %6 ], [ %295, %293 ]
%145 = icmp sgt i32 %1, 0
br i1 %145, label %146, label %299
146: ; preds = %142
%147 = add i32 %1, -1
%148 = zext i32 %147 to i64
%149 = add nuw nsw i64 %148, 1
%150 = icmp ult i32 %147, 7
br i1 %150, label %237, label %151
151: ; preds = %146
%152 = add i32 %1, -1
%153 = zext i32 %152 to i64
%154 = add nuw nsw i64 %153, 1
%155 = getelementptr float, float* %143, i64 %154
%156 = getelementptr float, float* %144, i64 %154
%157 = icmp ult float* %143, %156
%158 = icmp ult float* %144, %155
%159 = and i1 %157, %158
br i1 %159, label %237, label %160
160: ; preds = %151
%161 = and i64 %149, 8589934584
%162 = getelementptr float, float* %144, i64 %161
%163 = getelementptr float, float* %143, i64 %161
%164 = trunc i64 %161 to i32
%165 = insertelement <4 x double> poison, double %5, i64 0
%166 = shufflevector <4 x double> %165, <4 x double> poison, <4 x i32> zeroinitializer
%167 = insertelement <4 x double> poison, double %5, i64 0
%168 = shufflevector <4 x double> %167, <4 x double> poison, <4 x i32> zeroinitializer
%169 = add nsw i64 %161, -8
%170 = lshr exact i64 %169, 3
%171 = add nuw nsw i64 %170, 1
%172 = and i64 %171, 1
%173 = icmp eq i64 %169, 0
br i1 %173, label %215, label %174
174: ; preds = %160
%175 = and i64 %171, 4611686018427387902
br label %176
176: ; preds = %176, %174
%177 = phi i64 [ 0, %174 ], [ %212, %176 ]
%178 = phi i64 [ 0, %174 ], [ %213, %176 ]
%179 = getelementptr float, float* %144, i64 %177
%180 = getelementptr float, float* %143, i64 %177
%181 = bitcast float* %179 to <4 x float>*
%182 = load <4 x float>, <4 x float>* %181
%183 = getelementptr float, float* %179, i64 4
%184 = bitcast float* %183 to <4 x float>*
%185 = load <4 x float>, <4 x float>* %184
%186 = fpext <4 x float> %182 to <4 x double>
%187 = fpext <4 x float> %185 to <4 x double>
%188 = fmul <4 x double> %166, %186
%189 = fmul <4 x double> %168, %187
%190 = fptrunc <4 x double> %188 to <4 x float>
%191 = fptrunc <4 x double> %189 to <4 x float>
%192 = bitcast float* %180 to <4 x float>*
store <4 x float> %190, <4 x float>* %192
%193 = getelementptr float, float* %180, i64 4
%194 = bitcast float* %193 to <4 x float>*
store <4 x float> %191, <4 x float>* %194
%195 = or i64 %177, 8
%196 = getelementptr float, float* %144, i64 %195
%197 = getelementptr float, float* %143, i64 %195
%198 = bitcast float* %196 to <4 x float>*
%199 = load <4 x float>, <4 x float>* %198
%200 = getelementptr float, float* %196, i64 4
%201 = bitcast float* %200 to <4 x float>*
%202 = load <4 x float>, <4 x float>* %201
%203 = fpext <4 x float> %199 to <4 x double>
%204 = fpext <4 x float> %202 to <4 x double>
%205 = fmul <4 x double> %166, %203
%206 = fmul <4 x double> %168, %204
%207 = fptrunc <4 x double> %205 to <4 x float>
%208 = fptrunc <4 x double> %206 to <4 x float>
%209 = bitcast float* %197 to <4 x float>*
store <4 x float> %207, <4 x float>* %209
%210 = getelementptr float, float* %197, i64 4
%211 = bitcast float* %210 to <4 x float>*
store <4 x float> %208, <4 x float>* %211
%212 = add nuw i64 %177, 16
%213 = add i64 %178, 2
%214 = icmp eq i64 %213, %175
br i1 %214, label %215, label %176
215: ; preds = %176, %160
%216 = phi i64 [ 0, %160 ], [ %212, %176 ]
%217 = icmp eq i64 %172, 0
br i1 %217, label %235, label %218
218: ; preds = %215
%219 = getelementptr float, float* %144, i64 %216
%220 = getelementptr float, float* %143, i64 %216
%221 = bitcast float* %219 to <4 x float>*
%222 = load <4 x float>, <4 x float>* %221
%223 = getelementptr float, float* %219, i64 4
%224 = bitcast float* %223 to <4 x float>*
%225 = load <4 x float>, <4 x float>* %224
%226 = fpext <4 x float> %222 to <4 x double>
%227 = fpext <4 x float> %225 to <4 x double>
%228 = fmul <4 x double> %166, %226
%229 = fmul <4 x double> %168, %227
%230 = fptrunc <4 x double> %228 to <4 x float>
%231 = fptrunc <4 x double> %229 to <4 x float>
%232 = bitcast float* %220 to <4 x float>*
store <4 x float> %230, <4 x float>* %232
%233 = getelementptr float, float* %220, i64 4
%234 = bitcast float* %233 to <4 x float>*
store <4 x float> %231, <4 x float>* %234
br label %235
235: ; preds = %215, %218
%236 = icmp eq i64 %149, %161
br i1 %236, label %299, label %237
237: ; preds = %151, %146, %235
%238 = phi float* [ %144, %151 ], [ %144, %146 ], [ %162, %235 ]
%239 = phi float* [ %143, %151 ], [ %143, %146 ], [ %163, %235 ]
%240 = phi i32 [ 0, %151 ], [ 0, %146 ], [ %164, %235 ]
%241 = sub i32 %1, %240
%242 = xor i32 %240, -1
%243 = add i32 %242, %1
%244 = and i32 %241, 3
%245 = icmp eq i32 %244, 0
br i1 %245, label %260, label %246
246: ; preds = %237, %246
%247 = phi float* [ %256, %246 ], [ %238, %237 ]
%248 = phi float* [ %255, %246 ], [ %239, %237 ]
%249 = phi i32 [ %257, %246 ], [ %240, %237 ]
%250 = phi i32 [ %258, %246 ], [ 0, %237 ]
%251 = load float, float* %247
%252 = fpext float %251 to double
%253 = fmul double %252, %5
%254 = fptrunc double %253 to float
store float %254, float* %248
%255 = getelementptr inbounds float, float* %248, i64 1
%256 = getelementptr inbounds float, float* %247, i64 1
%257 = add nuw nsw i32 %249, 1
%258 = add i32 %250, 1
%259 = icmp eq i32 %258, %244
br i1 %259, label %260, label %246
260: ; preds = %246, %237
%261 = phi float* [ undef, %237 ], [ %255, %246 ]
%262 = phi float* [ %238, %237 ], [ %256, %246 ]
%263 = phi float* [ %239, %237 ], [ %255, %246 ]
%264 = phi i32 [ %240, %237 ], [ %257, %246 ]
%265 = icmp ult i32 %243, 3
br i1 %265, label %299, label %314
266: ; preds = %133, %266
%267 = phi float* [ %290, %266 ], [ %137, %133 ]
%268 = phi float* [ %289, %266 ], [ %138, %133 ]
%269 = phi float* [ %288, %266 ], [ %139, %133 ]
%270 = phi i32 [ %291, %266 ], [ %140, %133 ]
%271 = load float, float* %268
%272 = fpext float %271 to double
%273 = load float, float* %267
%274 = fpext float %273 to double
%275 = fmul double %274, %4
%276 = tail call double @llvm.fmuladd.f64(double %272, double %5, double %275)
%277 = fptrunc double %276 to float
store float %277, float* %269
%278 = getelementptr inbounds float, float* %269, i64 1
%279 = getelementptr inbounds float, float* %268, i64 1
%280 = getelementptr inbounds float, float* %267, i64 1
%281 = load float, float* %279
%282 = fpext float %281 to double
%283 = load float, float* %280
%284 = fpext float %283 to double
%285 = fmul double %284, %4
%286 = tail call double @llvm.fmuladd.f64(double %282, double %5, double %285)
%287 = fptrunc double %286 to float
store float %287, float* %278
%288 = getelementptr inbounds float, float* %269, i64 2
%289 = getelementptr inbounds float, float* %268, i64 2
%290 = getelementptr inbounds float, float* %267, i64 2
%291 = add nuw nsw i32 %270, 2
%292 = icmp eq i32 %291, %1
br i1 %292, label %293, label %266
293: ; preds = %133, %266, %111, %41
%294 = phi float* [ %44, %41 ], [ %61, %111 ], [ %134, %133 ], [ %288, %266 ]
%295 = phi float* [ %43, %41 ], [ %60, %111 ], [ %135, %133 ], [ %289, %266 ]
%296 = phi float* [ %42, %41 ], [ %59, %111 ], [ %136, %133 ], [ %290, %266 ]
%297 = add nuw nsw i32 %45, 1
%298 = icmp eq i32 %297, %11
br i1 %298, label %142, label %41
299: ; preds = %260, %314, %235, %142
%300 = phi float* [ %143, %142 ], [ %163, %235 ], [ %261, %260 ], [ %340, %314 ]
%301 = icmp sgt i32 %3, 0
br i1 %301, label %302, label %387
302: ; preds = %299
%303 = add i32 %1, -1
%304 = zext i32 %303 to i64
%305 = sub nsw i64 0, %304
%306 = zext i32 %1 to i64
%307 = shl nuw nsw i64 %306, 2
%308 = xor i64 %304, -1
%309 = add i32 %3, -1
%310 = and i32 %3, 3
%311 = icmp ult i32 %309, 3
br i1 %311, label %373, label %312
312: ; preds = %302
%313 = and i32 %3, -4
br label %344
314: ; preds = %260, %314
%315 = phi float* [ %341, %314 ], [ %262, %260 ]
%316 = phi float* [ %340, %314 ], [ %263, %260 ]
%317 = phi i32 [ %342, %314 ], [ %264, %260 ]
%318 = load float, float* %315
%319 = fpext float %318 to double
%320 = fmul double %319, %5
%321 = fptrunc double %320 to float
store float %321, float* %316
%322 = getelementptr inbounds float, float* %316, i64 1
%323 = getelementptr inbounds float, float* %315, i64 1
%324 = load float, float* %323
%325 = fpext float %324 to double
%326 = fmul double %325, %5
%327 = fptrunc double %326 to float
store float %327, float* %322
%328 = getelementptr inbounds float, float* %316, i64 2
%329 = getelementptr inbounds float, float* %315, i64 2
%330 = load float, float* %329
%331 = fpext float %330 to double
%332 = fmul double %331, %5
%333 = fptrunc double %332 to float
store float %333, float* %328
%334 = getelementptr inbounds float, float* %316, i64 3
%335 = getelementptr inbounds float, float* %315, i64 3
%336 = load float, float* %335
%337 = fpext float %336 to double
%338 = fmul double %337, %5
%339 = fptrunc double %338 to float
store float %339, float* %334
%340 = getelementptr inbounds float, float* %316, i64 4
%341 = getelementptr inbounds float, float* %315, i64 4
%342 = add nuw nsw i32 %317, 4
%343 = icmp eq i32 %342, %1
br i1 %343, label %299, label %314
344: ; preds = %369, %312
%345 = phi float* [ %300, %312 ], [ %370, %369 ]
%346 = phi i32 [ 0, %312 ], [ %371, %369 ]
br i1 %145, label %347, label %351
347: ; preds = %344
%348 = getelementptr float, float* %345, i64 %305
%349 = bitcast float* %348 to i8*
%350 = getelementptr float, float* %345, i64 %308
br label %351
351: ; preds = %347, %344
%352 = phi float* [ %345, %344 ], [ %350, %347 ]
br i1 %145, label %353, label %357
353: ; preds = %351
%354 = getelementptr float, float* %352, i64 %305
%355 = bitcast float* %354 to i8*
%356 = getelementptr float, float* %352, i64 %308
br label %357
357: ; preds = %353, %351
%358 = phi float* [ %352, %351 ], [ %356, %353 ]
br i1 %145, label %359, label %363
359: ; preds = %357
%360 = getelementptr float, float* %358, i64 %305
%361 = bitcast float* %360 to i8*
%362 = getelementptr float, float* %358, i64 %308
br label %363
363: ; preds = %359, %357
%364 = phi float* [ %358, %357 ], [ %362, %359 ]
br i1 %145, label %365, label %369
365: ; preds = %363
%366 = getelementptr float, float* %364, i64 %305
%367 = bitcast float* %366 to i8*
%368 = getelementptr float, float* %364, i64 %308
br label %369
369: ; preds = %365, %363
%370 = phi float* [ %364, %363 ], [ %368, %365 ]
%371 = add i32 %346, 4
%372 = icmp eq i32 %371, %313
br i1 %372, label %373, label %344
373: ; preds = %369, %302
%374 = phi float* [ %300, %302 ], [ %370, %369 ]
%375 = icmp eq i32 %310, 0
br i1 %375, label %387, label %376
376: ; preds = %373, %383
%377 = phi float* [ %384, %383 ], [ %374, %373 ]
%378 = phi i32 [ %385, %383 ], [ 0, %373 ]
br i1 %145, label %379, label %383
379: ; preds = %376
%380 = getelementptr float, float* %377, i64 %305
%381 = bitcast float* %380 to i8*
%382 = getelementptr float, float* %377, i64 %308
br label %383
383: ; preds = %379, %376
%384 = phi float* [ %377, %376 ], [ %382, %379 ]
%385 = add i32 %378, 1
%386 = icmp eq i32 %385, %310
br i1 %386, label %387, label %376
387: ; preds = %373, %383, %299
ret void
}