void push_ivector(int new_value, int *ivec, int n) {
  int i;
  for (i = n; i >= 2; i--)
    ivec[i] = ivec[i - 1];
  ivec[1] = new_value;
}


x86 assembly (clang, -O0):
<push_ivector>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x18(%rbp)
cmpl   $0x2,-0x18(%rbp)
jl     1147 <push_ivector+0x47>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    1114 <push_ivector+0x14>
mov    -0x4(%rbp),%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x4(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<push_ivector>:
push   %r15
push   %r14
push   %r12
push   %rbx
cmp    $0x2,%edx
jl     1144 <push_ivector+0x44>
mov    %edx,%ebx
xor    %r8d,%r8d
mov    %rbx,%rax
sub    $0x2,%rax
mov    $0x0,%r11d
cmovae %rax,%r11
add    $0x1,%r11
cmp    $0x8,%r11
jae    114f <push_ivector+0x4f>
add    $0x1,%rbx
lea    -0x2(%rbx),%eax
mov    (%rsi,%rax,4),%eax
mov    %eax,-0x4(%rsi,%rbx,4)
add    $0xffffffffffffffff,%rbx
cmp    $0x2,%rbx
ja     1130 <push_ivector+0x30>
mov    %edi,0x4(%rsi)
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret
mov    %ebx,%ecx
sub    $0x2,%ecx
cmovb  %r8d,%ecx
mov    %rbx,%rax
sub    $0x2,%rax
cmovae %rax,%r8
add    $0xffffffff,%edx
cmp    %ecx,%edx
jb     112c <push_ivector+0x2c>
mov    %r8,%rax
shr    $0x20,%rax
jne    112c <push_ivector+0x2c>
lea    (%rsi,%rbx,4),%rax
shl    $0x2,%r8
mov    %rax,%rcx
sub    %r8,%rcx
cmp    %rax,%rcx
ja     112c <push_ivector+0x2c>
xor    %eax,%eax
test   %al,%al
jne    112c <push_ivector+0x2c>
lea    (%rsi,%rdx,4),%rax
mov    %rax,%rcx
sub    %r8,%rcx
cmp    %rax,%rcx
ja     112c <push_ivector+0x2c>
xor    %eax,%eax
test   %al,%al
jne    112c <push_ivector+0x2c>
cmp    $0x2,%rbx
mov    $0x2,%ecx
cmovb  %rbx,%rcx
lea    (%rsi,%rcx,4),%r8
lea    (%rsi,%rdx,4),%rax
add    $0x4,%rax
cmp    %rax,%r8
jae    11da <push_ivector+0xda>
lea    (%rsi,%rbx,4),%rax
add    $0x4,%rax
add    %rdx,%rcx
sub    %rbx,%rcx
lea    (%rsi,%rcx,4),%rcx
cmp    %rax,%rcx
jb     112c <push_ivector+0x2c>
mov    $0xffffffff,%r8d
mov    %r11,%r9
and    $0xfffffffffffffff8,%r9
lea    -0x8(%r9),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
test   %rax,%rax
je     1296 <push_ivector+0x196>
mov    %r10,%rcx
and    $0xfffffffffffffffe,%rcx
lea    (%rsi,%rbx,4),%r12
add    $0xfffffffffffffff4,%r12
lea    (%rbx,%r8,1),%r14
add    $0xfffffffffffffff8,%r14
lea    (%rbx,%r8,1),%r15
xor    %edx,%edx
nopl   0x0(%rax)
lea    (%r15,%rdx,1),%eax
movups -0x1c(%rsi,%rax,4),%xmm0
movups -0xc(%rsi,%rax,4),%xmm1
movups %xmm1,(%r12,%rdx,4)
movups %xmm0,-0x10(%r12,%rdx,4)
lea    (%r14,%rdx,1),%eax
movups -0x1c(%rsi,%rax,4),%xmm0
movups -0xc(%rsi,%rax,4),%xmm1
movups %xmm1,-0x20(%r12,%rdx,4)
movups %xmm0,-0x30(%r12,%rdx,4)
add    $0xfffffffffffffff0,%rdx
add    $0xfffffffffffffffe,%rcx
jne    1220 <push_ivector+0x120>
neg    %rdx
test   $0x1,%r10b
je     1285 <push_ivector+0x185>
mov    %rbx,%rax
sub    %rdx,%rax
add    %eax,%r8d
movups -0x1c(%rsi,%r8,4),%xmm0
movups -0xc(%rsi,%r8,4),%xmm1
movups %xmm1,-0xc(%rsi,%rax,4)
movups %xmm0,-0x1c(%rsi,%rax,4)
cmp    %r9,%r11
je     1144 <push_ivector+0x44>
sub    %r9,%rbx
jmp    112c <push_ivector+0x2c>
xor    %edx,%edx
test   $0x1,%r10b
jne    1266 <push_ivector+0x166>
jmp    1285 <push_ivector+0x185>

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

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