void listShiftRightAdd(float *list, int len, float new) {
  for (int i = len - 1; i > 0; i--) {
    list[i] = list[i - 1];
  }
  list[0] = new;
}


x86 assembly (clang, -O0):
<listShiftRightAdd>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movss  %xmm0,-0x10(%rbp)
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x0,-0x14(%rbp)
jle    1150 <listShiftRightAdd+0x50>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    1119 <listShiftRightAdd+0x19>
movss  -0x10(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<listShiftRightAdd>:
push   %r14
push   %rbx
cmp    $0x2,%esi
jl     1163 <listShiftRightAdd+0x63>
mov    $0xfffffffe,%eax
mov    %esi,%ebx
xor    %r10d,%r10d
mov    %rbx,%rdx
sub    $0x2,%rdx
mov    $0x0,%r9d
cmovae %rdx,%r9
add    $0x1,%r9
cmp    $0x8,%r9
jae    116b <listShiftRightAdd+0x6b>
add    %rbx,%rax
add    $0xffffffffffffffff,%rbx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %eax,%ecx
movss  (%rdi,%rcx,4),%xmm1
mov    %ebx,%ecx
movss  %xmm1,(%rdi,%rcx,4)
add    $0xffffffffffffffff,%rax
lea    -0x1(%rbx),%rcx
add    $0x1,%rbx
cmp    $0x2,%rbx
mov    %rcx,%rbx
ja     1140 <listShiftRightAdd+0x40>
movss  %xmm0,(%rdi)
pop    %rbx
pop    %r14
ret
mov    %ebx,%edx
sub    $0x2,%edx
cmovb  %r10d,%edx
mov    %rbx,%rcx
sub    $0x2,%rcx
cmovae %rcx,%r10
lea    -0x1(%rsi),%r8d
cmp    %edx,%r8d
jb     112d <listShiftRightAdd+0x2d>
mov    %r10,%r11
shr    $0x20,%r11
jne    112d <listShiftRightAdd+0x2d>
add    $0xfffffffe,%esi
cmp    %edx,%esi
jb     112d <listShiftRightAdd+0x2d>
test   %r11,%r11
jne    112d <listShiftRightAdd+0x2d>
lea    (%rdi,%r8,4),%rcx
shl    $0x2,%r10
mov    %rcx,%rdx
sub    %r10,%rdx
cmp    %rcx,%rdx
ja     112d <listShiftRightAdd+0x2d>
xor    %ecx,%ecx
test   %cl,%cl
jne    112d <listShiftRightAdd+0x2d>
lea    (%rdi,%rsi,4),%rcx
mov    %rcx,%rdx
sub    %r10,%rdx
cmp    %rcx,%rdx
ja     112d <listShiftRightAdd+0x2d>
xor    %ecx,%ecx
test   %cl,%cl
jne    112d <listShiftRightAdd+0x2d>
cmp    $0x2,%rbx
mov    $0x2,%edx
cmovb  %rbx,%rdx
lea    (%rdx,%r8,1),%rcx
sub    %rbx,%rcx
lea    (%rdi,%rcx,4),%r10
lea    (%rdi,%rsi,4),%rcx
add    $0x4,%rcx
cmp    %rcx,%r10
jae    121b <listShiftRightAdd+0x11b>
lea    (%rdi,%r8,4),%rcx
add    $0x4,%rcx
add    %rsi,%rdx
sub    %rbx,%rdx
lea    (%rdi,%rdx,4),%rdx
cmp    %rcx,%rdx
jb     112d <listShiftRightAdd+0x2d>
mov    %r9,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rcx
mov    %rcx,%r10
shr    $0x3,%r10
add    $0x1,%r10
test   %rcx,%rcx
je     12c9 <listShiftRightAdd+0x1c9>
mov    %r10,%r14
and    $0xfffffffffffffffe,%r14
lea    (%rax,%rbx,1),%rdx
add    $0xfffffffffffffff8,%rdx
xor    %r11d,%r11d
nopl   0x0(%rax)
lea    0x9(%rdx),%ecx
lea    0x8(%rdx),%esi
movups -0x1c(%rdi,%rsi,4),%xmm1
movups -0xc(%rdi,%rsi,4),%xmm2
movups %xmm2,-0xc(%rdi,%rcx,4)
movups %xmm1,-0x1c(%rdi,%rcx,4)
mov    %edx,%ecx
lea    0x1(%rdx),%esi
movups -0x1c(%rdi,%rcx,4),%xmm1
movups -0xc(%rdi,%rcx,4),%xmm2
movups %xmm2,-0xc(%rdi,%rsi,4)
movups %xmm1,-0x1c(%rdi,%rsi,4)
add    $0x10,%r11
add    $0xfffffffffffffff0,%rdx
add    $0xfffffffffffffffe,%r14
jne    1250 <listShiftRightAdd+0x150>
test   $0x1,%r10b
je     12b8 <listShiftRightAdd+0x1b8>
mov    %ebx,%ecx
sub    %r11d,%ecx
lea    (%rax,%rcx,1),%edx
add    %eax,%ecx
add    $0x1,%ecx
movups -0x1c(%rdi,%rdx,4),%xmm1
movups -0xc(%rdi,%rdx,4),%xmm2
movups %xmm2,-0xc(%rdi,%rcx,4)
movups %xmm1,-0x1c(%rdi,%rcx,4)
cmp    %r8,%r9
je     1163 <listShiftRightAdd+0x63>
sub    %r8,%rbx
jmp    112d <listShiftRightAdd+0x2d>
xor    %r11d,%r11d
test   $0x1,%r10b
jne    1297 <listShiftRightAdd+0x197>
jmp    12b8 <listShiftRightAdd+0x1b8>

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

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