void tr_convert_float_pcm16(float *pFloatData, signed short int *pOutput,
                            unsigned int pNumSamples) {
  const double gain = 32767.0;
  unsigned int remainder = pNumSamples % 8;
  pNumSamples -= remainder;
  while (pNumSamples > 0) {
    *pOutput++ = (*pFloatData++) * gain;
    *pOutput++ = (*pFloatData++) * gain;
    *pOutput++ = (*pFloatData++) * gain;
    *pOutput++ = (*pFloatData++) * gain;
    *pOutput++ = (*pFloatData++) * gain;
    *pOutput++ = (*pFloatData++) * gain;
    *pOutput++ = (*pFloatData++) * gain;
    *pOutput++ = (*pFloatData++) * gain;
    pNumSamples -= 8;
  }
  switch (remainder) {
  case 7:
    *pOutput++ = (*pFloatData++) * gain;
  case 6:
    *pOutput++ = (*pFloatData++) * gain;
  case 5:
    *pOutput++ = (*pFloatData++) * gain;
  case 4:
    *pOutput++ = (*pFloatData++) * gain;
  case 3:
    *pOutput++ = (*pFloatData++) * gain;
  case 2:
    *pOutput++ = (*pFloatData++) * gain;
  case 1:
    *pOutput++ = (*pFloatData++) * gain;
  }
}


x86 assembly (clang, -O0):
<tr_convert_float_pcm16>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movsd  0xee9(%rip),%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x14(%rbp),%eax
and    $0x7,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%ecx
mov    -0x14(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x0,-0x14(%rbp)
jbe    12f5 <tr_convert_float_pcm16+0x1f5>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xea7(%rip),%xmm1
movsd  %xmm1,-0x30(%rbp)
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %ax,%cx
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x2,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cx,(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %ax,%cx
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x2,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cx,(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %ax,%cx
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x2,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cx,(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %ax,%cx
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x2,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cx,(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %ax,%cx
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x2,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cx,(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %ax,%cx
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x2,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cx,(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %ax,%cx
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x2,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cx,(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %ax,%cx
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x2,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cx,(%rax)
mov    -0x14(%rbp),%eax
sub    $0x8,%eax
mov    %eax,-0x14(%rbp)
jmp    1130 <tr_convert_float_pcm16+0x30>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,%ecx
mov    %rcx,-0x38(%rbp)
sub    $0x6,%eax
ja     14c2 <tr_convert_float_pcm16+0x3c2>
mov    -0x38(%rbp),%rax
lea    0xcf3(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xcc3(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %ax,%cx
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x2,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cx,(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xc87(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %ax,%cx
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x2,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cx,(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xc4b(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %ax,%cx
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x2,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cx,(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xc0f(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %ax,%cx
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x2,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cx,(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xbd3(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %ax,%cx
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x2,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cx,(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xb97(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %ax,%cx
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x2,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cx,(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xb5b(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %ax,%cx
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x2,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cx,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<tr_convert_float_pcm16>:
push   %rbx
mov    %edx,%r8d
and    $0x7,%r8d
and    $0xfffffff8,%edx
je     1291 <tr_convert_float_pcm16+0x191>
mov    %edx,%r9d
add    $0xfffffff8,%r9d
je     1299 <tr_convert_float_pcm16+0x199>
shr    $0x3,%r9d
add    $0x1,%r9d
mov    %r9d,%r10d
and    $0xfffffffe,%r10d
mov    %r10,%r11
shl    $0x5,%r11
add    %rdi,%r11
mov    %r10,%rax
shl    $0x4,%rax
add    %rsi,%rax
lea    0x0(,%r10,8),%ecx
sub    %ecx,%edx
xor    %ecx,%ecx
movapd 0xeaa(%rip),%xmm8
mov    %r10,%rbx
nopl   0x0(%rax)
movups (%rdi,%rcx,2),%xmm1
movups 0x10(%rdi,%rcx,2),%xmm4
movups 0x20(%rdi,%rcx,2),%xmm5
movups 0x30(%rdi,%rcx,2),%xmm2
movaps %xmm1,%xmm3
unpcklps %xmm5,%xmm3
movaps %xmm5,%xmm0
shufps $0x11,%xmm1,%xmm0
shufps $0xe2,%xmm1,%xmm0
movaps %xmm1,%xmm6
unpckhps %xmm5,%xmm6
shufps $0x33,%xmm1,%xmm5
shufps $0xe2,%xmm1,%xmm5
movaps %xmm4,%xmm10
unpcklps %xmm2,%xmm10
movaps %xmm2,%xmm7
shufps $0x11,%xmm4,%xmm7
shufps $0xe2,%xmm4,%xmm7
movaps %xmm4,%xmm9
cvtps2pd %xmm3,%xmm1
mulpd  %xmm8,%xmm1
cvttpd2dq %xmm1,%xmm1
cvtps2pd %xmm0,%xmm0
unpckhps %xmm2,%xmm9
mulpd  %xmm8,%xmm0
cvttpd2dq %xmm0,%xmm0
shufps $0x33,%xmm4,%xmm2
cvtps2pd %xmm6,%xmm3
mulpd  %xmm8,%xmm3
cvttpd2dq %xmm3,%xmm3
cvtps2pd %xmm5,%xmm5
shufps $0xe2,%xmm4,%xmm2
mulpd  %xmm8,%xmm5
cvttpd2dq %xmm5,%xmm5
punpcklwd %xmm0,%xmm1
cvtps2pd %xmm10,%xmm0
mulpd  %xmm8,%xmm0
cvttpd2dq %xmm0,%xmm4
cvtps2pd %xmm7,%xmm0
punpcklwd %xmm5,%xmm3
mulpd  %xmm8,%xmm0
cvttpd2dq %xmm0,%xmm0
punpcklwd %xmm0,%xmm4
cvtps2pd %xmm9,%xmm0
mulpd  %xmm8,%xmm0
cvttpd2dq %xmm0,%xmm0
cvtps2pd %xmm2,%xmm2
mulpd  %xmm8,%xmm2
cvttpd2dq %xmm2,%xmm2
punpcklwd %xmm2,%xmm0
pshufd $0xe8,%xmm1,%xmm2
pshuflw $0xd8,%xmm2,%xmm2
pshufd $0xe8,%xmm3,%xmm5
pshuflw $0xd8,%xmm5,%xmm5
punpcklqdq %xmm5,%xmm2
pshufd $0xe8,%xmm4,%xmm5
pshuflw $0xd8,%xmm5,%xmm5
pshufd $0xe8,%xmm0,%xmm6
pshuflw $0xd8,%xmm6,%xmm6
punpcklqdq %xmm6,%xmm5
psrad  $0x10,%xmm5
psrad  $0x10,%xmm2
packssdw %xmm5,%xmm2
punpckldq %xmm0,%xmm4
punpckldq %xmm3,%xmm1
punpcklqdq %xmm4,%xmm1
movdqu %xmm1,(%rsi,%rcx,1)
movdqu %xmm2,0x10(%rsi,%rcx,1)
add    $0x20,%rcx
add    $0xfffffffffffffffe,%rbx
jne    1160 <tr_convert_float_pcm16+0x60>
cmp    %r9,%r10
jne    129f <tr_convert_float_pcm16+0x19f>
jmp    12ff <tr_convert_float_pcm16+0x1ff>
mov    %rsi,%rax
mov    %rdi,%r11
jmp    12ff <tr_convert_float_pcm16+0x1ff>
mov    %rdi,%r11
mov    %rsi,%rax
movapd 0xd59(%rip),%xmm0
mov    %r11,%rcx
nopw   0x0(%rax,%rax,1)
lea    0x20(%rcx),%r11
cvtps2pd 0x18(%rcx),%xmm1
cvtps2pd 0x10(%rcx),%xmm2
cvtps2pd 0x8(%rcx),%xmm3
cvtps2pd (%rcx),%xmm4
mulpd  %xmm0,%xmm4
mulpd  %xmm0,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm1
cvttpd2dq %xmm1,%xmm1
cvttpd2dq %xmm2,%xmm2
cvttpd2dq %xmm3,%xmm3
unpcklpd %xmm1,%xmm2
cvttpd2dq %xmm4,%xmm1
unpcklpd %xmm3,%xmm1
packssdw %xmm2,%xmm1
movdqu %xmm1,(%rax)
add    $0x10,%rax
mov    %r11,%rcx
add    $0xfffffff8,%edx
jne    12b0 <tr_convert_float_pcm16+0x1b0>
add    $0xffffffff,%r8d
cmp    $0x6,%r8d
ja     13f5 <tr_convert_float_pcm16+0x2f5>
lea    0xd04(%rip),%rcx
movslq (%rcx,%r8,4),%rdx
add    %rcx,%rdx
jmp    *%rdx
movss  (%r11),%xmm0
add    $0x4,%r11
cvtss2sd %xmm0,%xmm0
mulsd  0xcde(%rip),%xmm0
cvttsd2si %xmm0,%ecx
mov    %cx,(%rax)
add    $0x2,%rax
movss  (%r11),%xmm0
add    $0x4,%r11
cvtss2sd %xmm0,%xmm0
mulsd  0xcbe(%rip),%xmm0
cvttsd2si %xmm0,%ecx
mov    %cx,(%rax)
add    $0x2,%rax
movss  (%r11),%xmm0
add    $0x4,%r11
cvtss2sd %xmm0,%xmm0
mulsd  0xc9e(%rip),%xmm0
cvttsd2si %xmm0,%ecx
mov    %cx,(%rax)
add    $0x2,%rax
movss  (%r11),%xmm0
add    $0x4,%r11
cvtss2sd %xmm0,%xmm0
mulsd  0xc7e(%rip),%xmm0
cvttsd2si %xmm0,%ecx
mov    %cx,(%rax)
add    $0x2,%rax
movss  (%r11),%xmm0
add    $0x4,%r11
cvtss2sd %xmm0,%xmm0
mulsd  0xc5e(%rip),%xmm0
cvttsd2si %xmm0,%ecx
mov    %cx,(%rax)
add    $0x2,%rax
movss  (%r11),%xmm0
add    $0x4,%r11
cvtss2sd %xmm0,%xmm0
mulsd  0xc3e(%rip),%xmm0
cvttsd2si %xmm0,%ecx
mov    %cx,(%rax)
add    $0x2,%rax
movss  (%r11),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  0xc22(%rip),%xmm0
cvttsd2si %xmm0,%ecx
mov    %cx,(%rax)
pop    %rbx
ret

LLVM IR (-O0):
define void @tr_convert_float_pcm16(float* %0, i16* %1, i32 %2) {
%4 = alloca float*
%5 = alloca i16*
%6 = alloca i32
%7 = alloca double
%8 = alloca i32
store float* %0, float** %4
store i16* %1, i16** %5
store i32 %2, i32* %6
store double 3.276700e+04, double* %7
%9 = load i32, i32* %6
%10 = urem i32 %9, 8
store i32 %10, i32* %8
%11 = load i32, i32* %8
%12 = load i32, i32* %6
%13 = sub i32 %12, %11
store i32 %13, i32* %6
br label %14
14: ; preds = %17, %3
%15 = load i32, i32* %6
%16 = icmp ugt i32 %15, 0
br i1 %16, label %17, label %84
17: ; preds = %14
%18 = load float*, float** %4
%19 = getelementptr inbounds float, float* %18, i32 1
store float* %19, float** %4
%20 = load float, float* %18
%21 = fpext float %20 to double
%22 = fmul double %21, 3.276700e+04
%23 = fptosi double %22 to i16
%24 = load i16*, i16** %5
%25 = getelementptr inbounds i16, i16* %24, i32 1
store i16* %25, i16** %5
store i16 %23, i16* %24
%26 = load float*, float** %4
%27 = getelementptr inbounds float, float* %26, i32 1
store float* %27, float** %4
%28 = load float, float* %26
%29 = fpext float %28 to double
%30 = fmul double %29, 3.276700e+04
%31 = fptosi double %30 to i16
%32 = load i16*, i16** %5
%33 = getelementptr inbounds i16, i16* %32, i32 1
store i16* %33, i16** %5
store i16 %31, i16* %32
%34 = load float*, float** %4
%35 = getelementptr inbounds float, float* %34, i32 1
store float* %35, float** %4
%36 = load float, float* %34
%37 = fpext float %36 to double
%38 = fmul double %37, 3.276700e+04
%39 = fptosi double %38 to i16
%40 = load i16*, i16** %5
%41 = getelementptr inbounds i16, i16* %40, i32 1
store i16* %41, i16** %5
store i16 %39, i16* %40
%42 = load float*, float** %4
%43 = getelementptr inbounds float, float* %42, i32 1
store float* %43, float** %4
%44 = load float, float* %42
%45 = fpext float %44 to double
%46 = fmul double %45, 3.276700e+04
%47 = fptosi double %46 to i16
%48 = load i16*, i16** %5
%49 = getelementptr inbounds i16, i16* %48, i32 1
store i16* %49, i16** %5
store i16 %47, i16* %48
%50 = load float*, float** %4
%51 = getelementptr inbounds float, float* %50, i32 1
store float* %51, float** %4
%52 = load float, float* %50
%53 = fpext float %52 to double
%54 = fmul double %53, 3.276700e+04
%55 = fptosi double %54 to i16
%56 = load i16*, i16** %5
%57 = getelementptr inbounds i16, i16* %56, i32 1
store i16* %57, i16** %5
store i16 %55, i16* %56
%58 = load float*, float** %4
%59 = getelementptr inbounds float, float* %58, i32 1
store float* %59, float** %4
%60 = load float, float* %58
%61 = fpext float %60 to double
%62 = fmul double %61, 3.276700e+04
%63 = fptosi double %62 to i16
%64 = load i16*, i16** %5
%65 = getelementptr inbounds i16, i16* %64, i32 1
store i16* %65, i16** %5
store i16 %63, i16* %64
%66 = load float*, float** %4
%67 = getelementptr inbounds float, float* %66, i32 1
store float* %67, float** %4
%68 = load float, float* %66
%69 = fpext float %68 to double
%70 = fmul double %69, 3.276700e+04
%71 = fptosi double %70 to i16
%72 = load i16*, i16** %5
%73 = getelementptr inbounds i16, i16* %72, i32 1
store i16* %73, i16** %5
store i16 %71, i16* %72
%74 = load float*, float** %4
%75 = getelementptr inbounds float, float* %74, i32 1
store float* %75, float** %4
%76 = load float, float* %74
%77 = fpext float %76 to double
%78 = fmul double %77, 3.276700e+04
%79 = fptosi double %78 to i16
%80 = load i16*, i16** %5
%81 = getelementptr inbounds i16, i16* %80, i32 1
store i16* %81, i16** %5
store i16 %79, i16* %80
%82 = load i32, i32* %6
%83 = sub i32 %82, 8
store i32 %83, i32* %6
br label %14
84: ; preds = %14
%85 = load i32, i32* %8
switch i32 %85, label %149 [
i32 7, label %86
i32 6, label %95
i32 5, label %104
i32 4, label %113
i32 3, label %122
i32 2, label %131
i32 1, label %140
]
86: ; preds = %84
%87 = load float*, float** %4
%88 = getelementptr inbounds float, float* %87, i32 1
store float* %88, float** %4
%89 = load float, float* %87
%90 = fpext float %89 to double
%91 = fmul double %90, 3.276700e+04
%92 = fptosi double %91 to i16
%93 = load i16*, i16** %5
%94 = getelementptr inbounds i16, i16* %93, i32 1
store i16* %94, i16** %5
store i16 %92, i16* %93
br label %95
95: ; preds = %84, %86
%96 = load float*, float** %4
%97 = getelementptr inbounds float, float* %96, i32 1
store float* %97, float** %4
%98 = load float, float* %96
%99 = fpext float %98 to double
%100 = fmul double %99, 3.276700e+04
%101 = fptosi double %100 to i16
%102 = load i16*, i16** %5
%103 = getelementptr inbounds i16, i16* %102, i32 1
store i16* %103, i16** %5
store i16 %101, i16* %102
br label %104
104: ; preds = %84, %95
%105 = load float*, float** %4
%106 = getelementptr inbounds float, float* %105, i32 1
store float* %106, float** %4
%107 = load float, float* %105
%108 = fpext float %107 to double
%109 = fmul double %108, 3.276700e+04
%110 = fptosi double %109 to i16
%111 = load i16*, i16** %5
%112 = getelementptr inbounds i16, i16* %111, i32 1
store i16* %112, i16** %5
store i16 %110, i16* %111
br label %113
113: ; preds = %84, %104
%114 = load float*, float** %4
%115 = getelementptr inbounds float, float* %114, i32 1
store float* %115, float** %4
%116 = load float, float* %114
%117 = fpext float %116 to double
%118 = fmul double %117, 3.276700e+04
%119 = fptosi double %118 to i16
%120 = load i16*, i16** %5
%121 = getelementptr inbounds i16, i16* %120, i32 1
store i16* %121, i16** %5
store i16 %119, i16* %120
br label %122
122: ; preds = %84, %113
%123 = load float*, float** %4
%124 = getelementptr inbounds float, float* %123, i32 1
store float* %124, float** %4
%125 = load float, float* %123
%126 = fpext float %125 to double
%127 = fmul double %126, 3.276700e+04
%128 = fptosi double %127 to i16
%129 = load i16*, i16** %5
%130 = getelementptr inbounds i16, i16* %129, i32 1
store i16* %130, i16** %5
store i16 %128, i16* %129
br label %131
131: ; preds = %84, %122
%132 = load float*, float** %4
%133 = getelementptr inbounds float, float* %132, i32 1
store float* %133, float** %4
%134 = load float, float* %132
%135 = fpext float %134 to double
%136 = fmul double %135, 3.276700e+04
%137 = fptosi double %136 to i16
%138 = load i16*, i16** %5
%139 = getelementptr inbounds i16, i16* %138, i32 1
store i16* %139, i16** %5
store i16 %137, i16* %138
br label %140
140: ; preds = %84, %131
%141 = load float*, float** %4
%142 = getelementptr inbounds float, float* %141, i32 1
store float* %142, float** %4
%143 = load float, float* %141
%144 = fpext float %143 to double
%145 = fmul double %144, 3.276700e+04
%146 = fptosi double %145 to i16
%147 = load i16*, i16** %5
%148 = getelementptr inbounds i16, i16* %147, i32 1
store i16* %148, i16** %5
store i16 %146, i16* %147
br label %149
149: ; preds = %140, %84
ret void
}

LLVM IR (-O2):
define void @tr_convert_float_pcm16(float* nocapture %0, i16* nocapture writeonly %1, i32 %2) {
%4 = and i32 %2, 7
%5 = and i32 %2, -8
%6 = icmp eq i32 %5, 0
br i1 %6, label %92, label %7
7: ; preds = %3
%8 = add i32 %5, -8
%9 = lshr exact i32 %8, 3
%10 = add nuw nsw i32 %9, 1
%11 = zext i32 %10 to i64
%12 = icmp eq i32 %8, 0
br i1 %12, label %74, label %13
13: ; preds = %7
%14 = and i64 %11, 1073741822
%15 = shl nuw nsw i64 %14, 3
%16 = getelementptr float, float* %0, i64 %15
%17 = shl nuw nsw i64 %14, 3
%18 = getelementptr i16, i16* %1, i64 %17
%19 = trunc i64 %14 to i32
%20 = mul i32 %19, -8
%21 = add i32 %5, %20
br label %22
22: ; preds = %22, %13
%23 = phi i64 [ 0, %13 ], [ %70, %22 ]
%24 = shl i64 %23, 3
%25 = getelementptr float, float* %0, i64 %24
%26 = shl i64 %23, 3
%27 = bitcast float* %25 to <16 x float>*
%28 = load <16 x float>, <16 x float>* %27
%29 = shufflevector <16 x float> %28, <16 x float> poison, <2 x i32> <i32 0, i32 8>
%30 = shufflevector <16 x float> %28, <16 x float> poison, <2 x i32> <i32 1, i32 9>
%31 = shufflevector <16 x float> %28, <16 x float> poison, <2 x i32> <i32 2, i32 10>
%32 = shufflevector <16 x float> %28, <16 x float> poison, <2 x i32> <i32 3, i32 11>
%33 = shufflevector <16 x float> %28, <16 x float> poison, <2 x i32> <i32 4, i32 12>
%34 = shufflevector <16 x float> %28, <16 x float> poison, <2 x i32> <i32 5, i32 13>
%35 = shufflevector <16 x float> %28, <16 x float> poison, <2 x i32> <i32 6, i32 14>
%36 = shufflevector <16 x float> %28, <16 x float> poison, <2 x i32> <i32 7, i32 15>
%37 = fpext <2 x float> %29 to <2 x double>
%38 = fmul <2 x double> %37, <double 3.276700e+04, double 3.276700e+04>
%39 = fptosi <2 x double> %38 to <2 x i16>
%40 = fpext <2 x float> %30 to <2 x double>
%41 = fmul <2 x double> %40, <double 3.276700e+04, double 3.276700e+04>
%42 = fptosi <2 x double> %41 to <2 x i16>
%43 = fpext <2 x float> %31 to <2 x double>
%44 = fmul <2 x double> %43, <double 3.276700e+04, double 3.276700e+04>
%45 = fptosi <2 x double> %44 to <2 x i16>
%46 = fpext <2 x float> %32 to <2 x double>
%47 = fmul <2 x double> %46, <double 3.276700e+04, double 3.276700e+04>
%48 = fptosi <2 x double> %47 to <2 x i16>
%49 = fpext <2 x float> %33 to <2 x double>
%50 = fmul <2 x double> %49, <double 3.276700e+04, double 3.276700e+04>
%51 = fptosi <2 x double> %50 to <2 x i16>
%52 = fpext <2 x float> %34 to <2 x double>
%53 = fmul <2 x double> %52, <double 3.276700e+04, double 3.276700e+04>
%54 = fptosi <2 x double> %53 to <2 x i16>
%55 = fpext <2 x float> %35 to <2 x double>
%56 = fmul <2 x double> %55, <double 3.276700e+04, double 3.276700e+04>
%57 = fptosi <2 x double> %56 to <2 x i16>
%58 = fpext <2 x float> %36 to <2 x double>
%59 = fmul <2 x double> %58, <double 3.276700e+04, double 3.276700e+04>
%60 = fptosi <2 x double> %59 to <2 x i16>
%61 = getelementptr inbounds i16, i16* %1, i64 %26
%62 = bitcast i16* %61 to <16 x i16>*
%63 = shufflevector <2 x i16> %39, <2 x i16> %42, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
%64 = shufflevector <2 x i16> %45, <2 x i16> %48, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
%65 = shufflevector <2 x i16> %51, <2 x i16> %54, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
%66 = shufflevector <2 x i16> %57, <2 x i16> %60, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
%67 = shufflevector <4 x i16> %63, <4 x i16> %64, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%68 = shufflevector <4 x i16> %65, <4 x i16> %66, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%69 = shufflevector <8 x i16> %67, <8 x i16> %68, <16 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14, i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
store <16 x i16> %69, <16 x i16>* %62
%70 = add nuw i64 %23, 2
%71 = icmp eq i64 %70, %14
br i1 %71, label %72, label %22
72: ; preds = %22
%73 = icmp eq i64 %14, %11
br i1 %73, label %92, label %74
74: ; preds = %7, %72
%75 = phi float* [ %0, %7 ], [ %16, %72 ]
%76 = phi i16* [ %1, %7 ], [ %18, %72 ]
%77 = phi i32 [ %5, %7 ], [ %21, %72 ]
br label %78
78: ; preds = %74, %78
%79 = phi float* [ %82, %78 ], [ %75, %74 ]
%80 = phi i16* [ %88, %78 ], [ %76, %74 ]
%81 = phi i32 [ %90, %78 ], [ %77, %74 ]
%82 = getelementptr inbounds float, float* %79, i64 8
%83 = bitcast float* %79 to <8 x float>*
%84 = load <8 x float>, <8 x float>* %83
%85 = fpext <8 x float> %84 to <8 x double>
%86 = fmul <8 x double> %85, <double 3.276700e+04, double 3.276700e+04, double 3.276700e+04, double 3.276700e+04, double 3.276700e+04, double 3.276700e+04, double 3.276700e+04, double 3.276700e+04>
%87 = fptosi <8 x double> %86 to <8 x i16>
%88 = getelementptr inbounds i16, i16* %80, i64 8
%89 = bitcast i16* %80 to <8 x i16>*
store <8 x i16> %87, <8 x i16>* %89
%90 = add i32 %81, -8
%91 = icmp eq i32 %90, 0
br i1 %91, label %92, label %78
92: ; preds = %78, %72, %3
%93 = phi i16* [ %1, %3 ], [ %18, %72 ], [ %88, %78 ]
%94 = phi float* [ %0, %3 ], [ %16, %72 ], [ %82, %78 ]
switch i32 %4, label %154 [
i32 7, label %95
i32 6, label %102
i32 5, label %111
i32 4, label %120
i32 3, label %129
i32 2, label %138
i32 1, label %147
]
95: ; preds = %92
%96 = getelementptr inbounds float, float* %94, i64 1
%97 = load float, float* %94
%98 = fpext float %97 to double
%99 = fmul double %98, 3.276700e+04
%100 = fptosi double %99 to i16
%101 = getelementptr inbounds i16, i16* %93, i64 1
store i16 %100, i16* %93
br label %102
102: ; preds = %92, %95
%103 = phi i16* [ %93, %92 ], [ %101, %95 ]
%104 = phi float* [ %94, %92 ], [ %96, %95 ]
%105 = getelementptr inbounds float, float* %104, i64 1
%106 = load float, float* %104
%107 = fpext float %106 to double
%108 = fmul double %107, 3.276700e+04
%109 = fptosi double %108 to i16
%110 = getelementptr inbounds i16, i16* %103, i64 1
store i16 %109, i16* %103
br label %111
111: ; preds = %92, %102
%112 = phi i16* [ %93, %92 ], [ %110, %102 ]
%113 = phi float* [ %94, %92 ], [ %105, %102 ]
%114 = getelementptr inbounds float, float* %113, i64 1
%115 = load float, float* %113
%116 = fpext float %115 to double
%117 = fmul double %116, 3.276700e+04
%118 = fptosi double %117 to i16
%119 = getelementptr inbounds i16, i16* %112, i64 1
store i16 %118, i16* %112
br label %120
120: ; preds = %92, %111
%121 = phi i16* [ %93, %92 ], [ %119, %111 ]
%122 = phi float* [ %94, %92 ], [ %114, %111 ]
%123 = getelementptr inbounds float, float* %122, i64 1
%124 = load float, float* %122
%125 = fpext float %124 to double
%126 = fmul double %125, 3.276700e+04
%127 = fptosi double %126 to i16
%128 = getelementptr inbounds i16, i16* %121, i64 1
store i16 %127, i16* %121
br label %129
129: ; preds = %92, %120
%130 = phi i16* [ %93, %92 ], [ %128, %120 ]
%131 = phi float* [ %94, %92 ], [ %123, %120 ]
%132 = getelementptr inbounds float, float* %131, i64 1
%133 = load float, float* %131
%134 = fpext float %133 to double
%135 = fmul double %134, 3.276700e+04
%136 = fptosi double %135 to i16
%137 = getelementptr inbounds i16, i16* %130, i64 1
store i16 %136, i16* %130
br label %138
138: ; preds = %92, %129
%139 = phi i16* [ %93, %92 ], [ %137, %129 ]
%140 = phi float* [ %94, %92 ], [ %132, %129 ]
%141 = getelementptr inbounds float, float* %140, i64 1
%142 = load float, float* %140
%143 = fpext float %142 to double
%144 = fmul double %143, 3.276700e+04
%145 = fptosi double %144 to i16
%146 = getelementptr inbounds i16, i16* %139, i64 1
store i16 %145, i16* %139
br label %147
147: ; preds = %92, %138
%148 = phi i16* [ %93, %92 ], [ %146, %138 ]
%149 = phi float* [ %94, %92 ], [ %141, %138 ]
%150 = load float, float* %149
%151 = fpext float %150 to double
%152 = fmul double %151, 3.276700e+04
%153 = fptosi double %152 to i16
store i16 %153, i16* %148
br label %154
154: ; preds = %147, %92
ret void
}