void sample_to_int(short *buff, int n) {
  short *s, *e;
  int *d;
  if (n < 1)
    return;
  s = buff + n;
  d = (int *)buff + n;
  e = buff;
  while (s != e) {
    *--d = (int)(*--s);
  }
}


x86 assembly (clang, -O0):
<sample_to_int>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
cmpl   $0x1,-0xc(%rbp)
jge    111a <sample_to_int+0x1a>
jmp    1180 <sample_to_int+0x80>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
shl    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
cmp    -0x20(%rbp),%rax
je     1180 <sample_to_int+0x80>
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffe,%rcx
mov    %rcx,-0x18(%rbp)
movswl -0x2(%rax),%ecx
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0xfffffffffffffffc,%rdx
mov    %rdx,-0x28(%rbp)
mov    %ecx,-0x4(%rax)
jmp    1148 <sample_to_int+0x48>
pop    %rbp
ret

x86 assembly (clang, -O2):
<sample_to_int>:
push   %rbx
test   %esi,%esi
jle    12b3 <sample_to_int+0x1b3>
mov    %esi,%edx
lea    (%rdi,%rdx,4),%rax
lea    (%rdi,%rdx,2),%rcx
lea    -0x1(%rdx),%rsi
movabs $0x7fffffffffffffff,%r10
ff ff 7f
and    %rsi,%r10
cmp    $0x7,%r10
jb     1290 <sample_to_int+0x190>
add    $0x1,%r10
mov    %r10,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rsi
mov    %rsi,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     12b5 <sample_to_int+0x1b5>
mov    %r9,%rsi
and    $0xfffffffffffffffe,%rsi
lea    (%rdi,%rdx,2),%r11
add    $0xfffffffffffffff8,%r11
lea    (%rdi,%rdx,4),%rbx
add    $0xfffffffffffffff0,%rbx
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movq   (%r11,%rdx,2),%xmm0
movq   -0x8(%r11,%rdx,2),%xmm1
pshufd $0xc4,%xmm0,%xmm0
pshuflw $0xac,%xmm0,%xmm0
pshufhw $0x24,%xmm0,%xmm0
psrad  $0x10,%xmm0
pshufd $0xc4,%xmm1,%xmm1
pshuflw $0xac,%xmm1,%xmm1
pshufhw $0x24,%xmm1,%xmm1
psrad  $0x10,%xmm1
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm0,(%rbx,%rdx,4)
pshufd $0x1b,%xmm1,%xmm0
movdqu %xmm0,-0x10(%rbx,%rdx,4)
movq   -0x10(%r11,%rdx,2),%xmm0
movq   -0x18(%r11,%rdx,2),%xmm1
pshufd $0xc4,%xmm0,%xmm0
pshuflw $0xac,%xmm0,%xmm0
pshufhw $0x24,%xmm0,%xmm0
psrad  $0x10,%xmm0
pshufd $0xc4,%xmm1,%xmm1
pshuflw $0xac,%xmm1,%xmm1
pshufhw $0x24,%xmm1,%xmm1
psrad  $0x10,%xmm1
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm0,-0x20(%rbx,%rdx,4)
pshufd $0x1b,%xmm1,%xmm0
movdqu %xmm0,-0x30(%rbx,%rdx,4)
add    $0xfffffffffffffff0,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1170 <sample_to_int+0x70>
neg    %rdx
test   $0x1,%r9b
je     127a <sample_to_int+0x17a>
lea    0x0(,%rdx,4),%rsi
mov    %rax,%rbx
sub    %rsi,%rbx
add    %rdx,%rdx
mov    %rcx,%rsi
sub    %rdx,%rsi
movq   -0x8(%rsi),%xmm0
movq   -0x10(%rsi),%xmm1
pshufd $0xc4,%xmm0,%xmm0
pshuflw $0xac,%xmm0,%xmm0
pshufhw $0x24,%xmm0,%xmm0
psrad  $0x10,%xmm0
pshufd $0xc4,%xmm1,%xmm1
pshuflw $0xac,%xmm1,%xmm1
pshufhw $0x24,%xmm1,%xmm1
psrad  $0x10,%xmm1
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm0,-0x10(%rbx)
pshufd $0x1b,%xmm1,%xmm0
movdqu %xmm0,-0x20(%rbx)
cmp    %r8,%r10
je     12b3 <sample_to_int+0x1b3>
lea    0x0(,%r8,4),%rdx
add    %r8,%r8
sub    %rdx,%rax
sub    %r8,%rcx
add    $0xfffffffffffffffc,%rax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movswl -0x2(%rcx),%edx
add    $0xfffffffffffffffe,%rcx
mov    %edx,(%rax)
add    $0xfffffffffffffffc,%rax
cmp    %rdi,%rcx
jne    12a0 <sample_to_int+0x1a0>
pop    %rbx
ret
xor    %edx,%edx
test   $0x1,%r9b
jne    121d <sample_to_int+0x11d>
jmp    127a <sample_to_int+0x17a>

LLVM IR (-O0):
define void @sample_to_int(i16* %0, i32 %1) {
%3 = alloca i16*
%4 = alloca i32
%5 = alloca i16*
%6 = alloca i16*
%7 = alloca i32*
store i16* %0, i16** %3
store i32 %1, i32* %4
%8 = load i32, i32* %4
%9 = icmp slt i32 %8, 1
br i1 %9, label %10, label %11
10: ; preds = %2
br label %33
11: ; preds = %2
%12 = load i16*, i16** %3
%13 = load i32, i32* %4
%14 = sext i32 %13 to i64
%15 = getelementptr inbounds i16, i16* %12, i64 %14
store i16* %15, i16** %5
%16 = load i16*, i16** %3
%17 = bitcast i16* %16 to i32*
%18 = load i32, i32* %4
%19 = sext i32 %18 to i64
%20 = getelementptr inbounds i32, i32* %17, i64 %19
store i32* %20, i32** %7
%21 = load i16*, i16** %3
store i16* %21, i16** %6
br label %22
22: ; preds = %26, %11
%23 = load i16*, i16** %5
%24 = load i16*, i16** %6
%25 = icmp ne i16* %23, %24
br i1 %25, label %26, label %33
26: ; preds = %22
%27 = load i16*, i16** %5
%28 = getelementptr inbounds i16, i16* %27, i32 -1
store i16* %28, i16** %5
%29 = load i16, i16* %28
%30 = sext i16 %29 to i32
%31 = load i32*, i32** %7
%32 = getelementptr inbounds i32, i32* %31, i32 -1
store i32* %32, i32** %7
store i32 %30, i32* %32
br label %22
33: ; preds = %10, %22
ret void
}

LLVM IR (-O2):
define void @sample_to_int(i16* %0, i32 %1) {
%3 = icmp slt i32 %1, 1
%4 = zext i32 %1 to i64
br i1 %3, label %121, label %5
5: ; preds = %2
%6 = bitcast i16* %0 to i32*
%7 = getelementptr inbounds i32, i32* %6, i64 %4
%8 = getelementptr inbounds i16, i16* %0, i64 %4
%9 = add nuw i64 %4, 9223372036854775807
%10 = and i64 %9, 9223372036854775807
%11 = add nuw i64 %10, 1
%12 = icmp ult i64 %10, 7
br i1 %12, label %110, label %13
13: ; preds = %5
%14 = and i64 %11, -8
%15 = sub i64 0, %14
%16 = getelementptr i32, i32* %7, i64 %15
%17 = sub i64 0, %14
%18 = getelementptr i16, i16* %8, i64 %17
%19 = add i64 %14, -8
%20 = lshr exact i64 %19, 3
%21 = add nuw nsw i64 %20, 1
%22 = and i64 %21, 1
%23 = icmp eq i64 %19, 0
br i1 %23, label %80, label %24
24: ; preds = %13
%25 = and i64 %21, 4611686018427387902
%26 = getelementptr i32, i32* %7, i64 -1
%27 = getelementptr i16, i16* %8, i64 -1
%28 = getelementptr i32, i32* %7, i64 -1
%29 = getelementptr i16, i16* %8, i64 -1
br label %30
30: ; preds = %30, %24
%31 = phi i64 [ 0, %24 ], [ %77, %30 ]
%32 = phi i64 [ 0, %24 ], [ %78, %30 ]
%33 = sub i64 0, %31
%34 = sub i64 0, %31
%35 = getelementptr inbounds i16, i16* %27, i64 %34
%36 = getelementptr inbounds i16, i16* %35, i64 -3
%37 = bitcast i16* %36 to <4 x i16>*
%38 = load <4 x i16>, <4 x i16>* %37
%39 = shufflevector <4 x i16> %38, <4 x i16> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%40 = getelementptr inbounds i16, i16* %35, i64 -4
%41 = getelementptr inbounds i16, i16* %40, i64 -3
%42 = bitcast i16* %41 to <4 x i16>*
%43 = load <4 x i16>, <4 x i16>* %42
%44 = shufflevector <4 x i16> %43, <4 x i16> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%45 = sext <4 x i16> %39 to <4 x i32>
%46 = sext <4 x i16> %44 to <4 x i32>
%47 = getelementptr inbounds i32, i32* %26, i64 %33
%48 = shufflevector <4 x i32> %45, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%49 = getelementptr inbounds i32, i32* %47, i64 -3
%50 = bitcast i32* %49 to <4 x i32>*
store <4 x i32> %48, <4 x i32>* %50
%51 = shufflevector <4 x i32> %46, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%52 = getelementptr inbounds i32, i32* %47, i64 -4
%53 = getelementptr inbounds i32, i32* %52, i64 -3
%54 = bitcast i32* %53 to <4 x i32>*
store <4 x i32> %51, <4 x i32>* %54
%55 = sub nuw nsw i64 -8, %31
%56 = sub nuw nsw i64 -8, %31
%57 = getelementptr inbounds i16, i16* %29, i64 %56
%58 = getelementptr inbounds i16, i16* %57, i64 -3
%59 = bitcast i16* %58 to <4 x i16>*
%60 = load <4 x i16>, <4 x i16>* %59
%61 = shufflevector <4 x i16> %60, <4 x i16> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%62 = getelementptr inbounds i16, i16* %57, i64 -4
%63 = getelementptr inbounds i16, i16* %62, i64 -3
%64 = bitcast i16* %63 to <4 x i16>*
%65 = load <4 x i16>, <4 x i16>* %64
%66 = shufflevector <4 x i16> %65, <4 x i16> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%67 = sext <4 x i16> %61 to <4 x i32>
%68 = sext <4 x i16> %66 to <4 x i32>
%69 = getelementptr inbounds i32, i32* %28, i64 %55
%70 = shufflevector <4 x i32> %67, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%71 = getelementptr inbounds i32, i32* %69, i64 -3
%72 = bitcast i32* %71 to <4 x i32>*
store <4 x i32> %70, <4 x i32>* %72
%73 = shufflevector <4 x i32> %68, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%74 = getelementptr inbounds i32, i32* %69, i64 -4
%75 = getelementptr inbounds i32, i32* %74, i64 -3
%76 = bitcast i32* %75 to <4 x i32>*
store <4 x i32> %73, <4 x i32>* %76
%77 = add nuw i64 %31, 16
%78 = add i64 %32, 2
%79 = icmp eq i64 %78, %25
br i1 %79, label %80, label %30
80: ; preds = %30, %13
%81 = phi i64 [ 0, %13 ], [ %77, %30 ]
%82 = icmp eq i64 %22, 0
br i1 %82, label %108, label %83
83: ; preds = %80
%84 = sub i64 0, %81
%85 = getelementptr i32, i32* %7, i64 -1
%86 = sub i64 0, %81
%87 = getelementptr i16, i16* %8, i64 -1
%88 = getelementptr inbounds i16, i16* %87, i64 %86
%89 = getelementptr inbounds i16, i16* %88, i64 -3
%90 = bitcast i16* %89 to <4 x i16>*
%91 = load <4 x i16>, <4 x i16>* %90
%92 = shufflevector <4 x i16> %91, <4 x i16> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%93 = getelementptr inbounds i16, i16* %88, i64 -4
%94 = getelementptr inbounds i16, i16* %93, i64 -3
%95 = bitcast i16* %94 to <4 x i16>*
%96 = load <4 x i16>, <4 x i16>* %95
%97 = shufflevector <4 x i16> %96, <4 x i16> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%98 = sext <4 x i16> %92 to <4 x i32>
%99 = sext <4 x i16> %97 to <4 x i32>
%100 = getelementptr inbounds i32, i32* %85, i64 %84
%101 = shufflevector <4 x i32> %98, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%102 = getelementptr inbounds i32, i32* %100, i64 -3
%103 = bitcast i32* %102 to <4 x i32>*
store <4 x i32> %101, <4 x i32>* %103
%104 = shufflevector <4 x i32> %99, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%105 = getelementptr inbounds i32, i32* %100, i64 -4
%106 = getelementptr inbounds i32, i32* %105, i64 -3
%107 = bitcast i32* %106 to <4 x i32>*
store <4 x i32> %104, <4 x i32>* %107
br label %108
108: ; preds = %80, %83
%109 = icmp eq i64 %11, %14
br i1 %109, label %121, label %110
110: ; preds = %5, %108
%111 = phi i32* [ %7, %5 ], [ %16, %108 ]
%112 = phi i16* [ %8, %5 ], [ %18, %108 ]
br label %113
113: ; preds = %110, %113
%114 = phi i32* [ %119, %113 ], [ %111, %110 ]
%115 = phi i16* [ %116, %113 ], [ %112, %110 ]
%116 = getelementptr inbounds i16, i16* %115, i64 -1
%117 = load i16, i16* %116
%118 = sext i16 %117 to i32
%119 = getelementptr inbounds i32, i32* %114, i64 -1
store i32 %118, i32* %119
%120 = icmp eq i16* %116, %0
br i1 %120, label %121, label %113
121: ; preds = %113, %108, %2
ret void
}