void swaprows(unsigned int size, float *matrix, unsigned int row1,
              unsigned int row2) {
  float buffer;
  int i;
  for (i = 0; i < size; i++) {
    buffer = matrix[row1 * size + i];
    matrix[row1 * size + i] = matrix[row2 * size + i];
    matrix[row2 * size + i] = buffer;
  }
}


x86 assembly (clang, -O0):
<swaprows>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    1190 <swaprows+0x90>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x20(%rbp),%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x20(%rbp),%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x20(%rbp),%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x1c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x20(%rbp),%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1118 <swaprows+0x18>
pop    %rbp
ret

x86 assembly (clang, -O2):
<swaprows>:
push   %r15
push   %r14
push   %rbx
test   %edi,%edi
je     119e <swaprows+0x9e>
imul   %edi,%edx
imul   %edi,%ecx
mov    %edi,%eax
cmp    $0x8,%edi
jae    11a4 <swaprows+0xa4>
xor    %r8d,%r8d
mov    %r8,%rdi
not    %rdi
test   $0x1,%al
je     114d <swaprows+0x4d>
lea    (%rdx,%r8,1),%r9d
movss  (%rsi,%r9,4),%xmm0
lea    (%rcx,%r8,1),%ebx
movss  (%rsi,%rbx,4),%xmm1
movss  %xmm1,(%rsi,%r9,4)
movss  %xmm0,(%rsi,%rbx,4)
or     $0x1,%r8
add    %rax,%rdi
je     119e <swaprows+0x9e>
add    %r8d,%edx
add    %r8d,%ecx
sub    %r8,%rax
nopl   0x0(%rax,%rax,1)
mov    %edx,%edi
movss  (%rsi,%rdi,4),%xmm0
mov    %ecx,%ebx
movss  (%rsi,%rbx,4),%xmm1
movss  %xmm1,(%rsi,%rdi,4)
movss  %xmm0,(%rsi,%rbx,4)
lea    0x1(%rdx),%edi
movss  (%rsi,%rdi,4),%xmm0
lea    0x1(%rcx),%ebx
movss  (%rsi,%rbx,4),%xmm1
movss  %xmm1,(%rsi,%rdi,4)
movss  %xmm0,(%rsi,%rbx,4)
add    $0x2,%edx
add    $0x2,%ecx
add    $0xfffffffffffffffe,%rax
jne    1160 <swaprows+0x60>
pop    %rbx
pop    %r14
pop    %r15
ret
lea    -0x1(%rax),%rdi
mov    %ecx,%ebx
add    %edi,%ebx
setb   %r9b
xor    %r8d,%r8d
mov    %edx,%ebx
add    %edi,%ebx
jb     1121 <swaprows+0x21>
shr    $0x20,%rdi
jne    1121 <swaprows+0x21>
test   %r9b,%r9b
jne    1121 <swaprows+0x21>
test   %rdi,%rdi
jne    1121 <swaprows+0x21>
mov    %edx,%edi
lea    (%rsi,%rdi,4),%r8
mov    %ecx,%r9d
lea    (%rax,%r9,1),%rbx
lea    (%rsi,%rbx,4),%rbx
xor    %r10d,%r10d
cmp    %rbx,%r8
jae    1206 <swaprows+0x106>
add    %rax,%rdi
lea    (%rsi,%rdi,4),%rdi
lea    (%rsi,%r9,4),%rbx
cmp    %rdi,%rbx
jb     111e <swaprows+0x1e>
mov    %eax,%r8d
and    $0xfffffff8,%r8d
lea    -0x8(%r8),%rdi
mov    %rdi,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rdi,%rdi
je     12a8 <swaprows+0x1a8>
mov    %r9,%r11
and    $0xfffffffffffffffe,%r11
xor    %r10d,%r10d
mov    %ecx,%r14d
mov    %edx,%r15d
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r15d,%edi
movups (%rsi,%rdi,4),%xmm0
movups 0x10(%rsi,%rdi,4),%xmm1
mov    %r14d,%ebx
movups (%rsi,%rbx,4),%xmm2
movups 0x10(%rsi,%rbx,4),%xmm3
movups %xmm2,(%rsi,%rdi,4)
movups %xmm3,0x10(%rsi,%rdi,4)
movups %xmm0,(%rsi,%rbx,4)
movups %xmm1,0x10(%rsi,%rbx,4)
lea    0x8(%r15),%edi
movups (%rsi,%rdi,4),%xmm0
movups 0x10(%rsi,%rdi,4),%xmm1
lea    0x8(%r14),%ebx
movups (%rsi,%rbx,4),%xmm2
movups 0x10(%rsi,%rbx,4),%xmm3
movups %xmm2,(%rsi,%rdi,4)
movups %xmm3,0x10(%rsi,%rdi,4)
movups %xmm0,(%rsi,%rbx,4)
movups %xmm1,0x10(%rsi,%rbx,4)
add    $0x10,%r15d
add    $0x10,%r14d
add    $0x10,%r10d
add    $0xfffffffffffffffe,%r11
jne    1240 <swaprows+0x140>
test   $0x1,%r9b
je     12dd <swaprows+0x1dd>
lea    (%rdx,%r10,1),%edi
movups (%rsi,%rdi,4),%xmm0
movups 0x10(%rsi,%rdi,4),%xmm1
add    %ecx,%r10d
movups (%rsi,%r10,4),%xmm2
movups 0x10(%rsi,%r10,4),%xmm3
movups %xmm2,(%rsi,%rdi,4)
movups %xmm3,0x10(%rsi,%rdi,4)
movups %xmm0,(%rsi,%r10,4)
movups %xmm1,0x10(%rsi,%r10,4)
cmp    %rax,%r8
jne    1121 <swaprows+0x21>
jmp    119e <swaprows+0x9e>

LLVM IR (-O0):
define void @swaprows(i32 %0, float* %1, i32 %2, i32 %3) {
%5 = alloca i32
%6 = alloca float*
%7 = alloca i32
%8 = alloca i32
%9 = alloca float
%10 = alloca i32
store i32 %0, i32* %5
store float* %1, float** %6
store i32 %2, i32* %7
store i32 %3, i32* %8
store i32 0, i32* %10
br label %11
11: ; preds = %51, %4
%12 = load i32, i32* %10
%13 = load i32, i32* %5
%14 = icmp ult i32 %12, %13
br i1 %14, label %15, label %54
15: ; preds = %11
%16 = load float*, float** %6
%17 = load i32, i32* %7
%18 = load i32, i32* %5
%19 = mul i32 %17, %18
%20 = load i32, i32* %10
%21 = add i32 %19, %20
%22 = zext i32 %21 to i64
%23 = getelementptr inbounds float, float* %16, i64 %22
%24 = load float, float* %23
store float %24, float* %9
%25 = load float*, float** %6
%26 = load i32, i32* %8
%27 = load i32, i32* %5
%28 = mul i32 %26, %27
%29 = load i32, i32* %10
%30 = add i32 %28, %29
%31 = zext i32 %30 to i64
%32 = getelementptr inbounds float, float* %25, i64 %31
%33 = load float, float* %32
%34 = load float*, float** %6
%35 = load i32, i32* %7
%36 = load i32, i32* %5
%37 = mul i32 %35, %36
%38 = load i32, i32* %10
%39 = add i32 %37, %38
%40 = zext i32 %39 to i64
%41 = getelementptr inbounds float, float* %34, i64 %40
store float %33, float* %41
%42 = load float, float* %9
%43 = load float*, float** %6
%44 = load i32, i32* %8
%45 = load i32, i32* %5
%46 = mul i32 %44, %45
%47 = load i32, i32* %10
%48 = add i32 %46, %47
%49 = zext i32 %48 to i64
%50 = getelementptr inbounds float, float* %43, i64 %49
store float %42, float* %50
br label %51
51: ; preds = %15
%52 = load i32, i32* %10
%53 = add nsw i32 %52, 1
store i32 %53, i32* %10
br label %11
54: ; preds = %11
ret void
}

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