void pasteCol(double A[1000][1000], double x[1000], int index, int n) {
  int i;
  for (i = index + 1; i < n; i++)
    A[i][index] = x[i];
}


x86 assembly (clang, -O0):
<pasteCol>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    115d <pasteCol+0x5d>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x1f40,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    111b <pasteCol+0x1b>
pop    %rbp
ret

x86 assembly (clang, -O2):
<pasteCol>:
push   %rbx
lea    0x1(%rdx),%eax
cmp    %ecx,%eax
jge    11d2 <pasteCol+0xd2>
movslq %edx,%r8
movslq %eax,%rbx
mov    %edx,%r10d
not    %r10d
add    %ecx,%r10d
mov    %ecx,%r9d
sub    %edx,%r9d
add    $0xfffffffe,%r9d
test   $0x3,%r10b
je     116b <pasteCol+0x6b>
imul   $0x1f40,%rbx,%rax
add    %rdi,%rax
lea    (%rax,%r8,8),%r10
not    %dl
add    %cl,%dl
movzbl %dl,%eax
and    $0x3,%eax
imul   $0x3e8,%rax,%r11
xor    %edx,%edx
nopl   0x0(%rax)
movsd  (%rsi,%rbx,8),%xmm0
movsd  %xmm0,(%r10,%rdx,8)
add    $0x1,%rbx
add    $0x3e8,%rdx
cmp    %edx,%r11d
jne    1150 <pasteCol+0x50>
cmp    $0x3,%r9d
jb     11d2 <pasteCol+0xd2>
mov    %ecx,%ecx
imul   $0x1f40,%rbx,%rax
add    %rax,%rdi
lea    (%rdi,%r8,8),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rbx,8),%xmm0
movsd  %xmm0,(%rdx)
movsd  0x8(%rsi,%rbx,8),%xmm0
movsd  %xmm0,0x1f40(%rdx)
movsd  0x10(%rsi,%rbx,8),%xmm0
movsd  %xmm0,0x3e80(%rdx)
movsd  0x18(%rsi,%rbx,8),%xmm0
movsd  %xmm0,0x5dc0(%rdx)
add    $0x4,%rbx
add    $0x7d00,%rdx
cmp    %ebx,%ecx
jne    1190 <pasteCol+0x90>
pop    %rbx
ret

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

LLVM IR (-O2):
define void @pasteCol([1000 x double]* nocapture writeonly %0, double* nocapture %1, i32 %2, i32 %3) {
%5 = add i32 %2, 1
%6 = icmp slt i32 %5, %3
br i1 %6, label %7, label %48
7: ; preds = %4
%8 = sext i32 %2 to i64
%9 = sext i32 %5 to i64
%10 = xor i32 %2, -1
%11 = add i32 %10, %3
%12 = add i32 %3, -2
%13 = sub i32 %12, %2
%14 = and i32 %11, 3
%15 = icmp eq i32 %14, 0
br i1 %15, label %25, label %16
16: ; preds = %7, %16
%17 = phi i64 [ %22, %16 ], [ %9, %7 ]
%18 = phi i32 [ %23, %16 ], [ 0, %7 ]
%19 = getelementptr inbounds double, double* %1, i64 %17
%20 = load double, double* %19
%21 = getelementptr inbounds [1000 x double], [1000 x double]* %0, i64 %17, i64 %8
store double %20, double* %21
%22 = add nsw i64 %17, 1
%23 = add i32 %18, 1
%24 = icmp eq i32 %23, %14
br i1 %24, label %25, label %16
25: ; preds = %16, %7
%26 = phi i64 [ %9, %7 ], [ %22, %16 ]
%27 = icmp ult i32 %13, 3
br i1 %27, label %48, label %28
28: ; preds = %25, %28
%29 = phi i64 [ %45, %28 ], [ %26, %25 ]
%30 = getelementptr inbounds double, double* %1, i64 %29
%31 = load double, double* %30
%32 = getelementptr inbounds [1000 x double], [1000 x double]* %0, i64 %29, i64 %8
store double %31, double* %32
%33 = add nsw i64 %29, 1
%34 = getelementptr inbounds double, double* %1, i64 %33
%35 = load double, double* %34
%36 = getelementptr inbounds [1000 x double], [1000 x double]* %0, i64 %33, i64 %8
store double %35, double* %36
%37 = add nsw i64 %29, 2
%38 = getelementptr inbounds double, double* %1, i64 %37
%39 = load double, double* %38
%40 = getelementptr inbounds [1000 x double], [1000 x double]* %0, i64 %37, i64 %8
store double %39, double* %40
%41 = add nsw i64 %29, 3
%42 = getelementptr inbounds double, double* %1, i64 %41
%43 = load double, double* %42
%44 = getelementptr inbounds [1000 x double], [1000 x double]* %0, i64 %41, i64 %8
store double %43, double* %44
%45 = add nsw i64 %29, 4
%46 = trunc i64 %45 to i32
%47 = icmp eq i32 %46, %3
br i1 %47, label %48, label %28
48: ; preds = %25, %28, %4
ret void
}