void sse_swap_rowf(float *r1, float *r2, int n) {
  int n4 = (n / 4) * 4;
  float *r14end = r1 + n4;
  while (r1 < r14end) {
    *r1 = *r2;
    r1++;
  }
}


x86 assembly (clang, -O0):
<sse_swap_rowf>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
shl    $0x2,%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    1162 <sse_swap_rowf+0x62>
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x8(%rbp)
jmp    1133 <sse_swap_rowf+0x33>
pop    %rbp
ret

x86 assembly (clang, -O2):
<sse_swap_rowf>:
lea    0x3(%rdx),%eax
test   %edx,%edx
cmovns %edx,%eax
cmp    $0x4,%edx
jl     1221 <sse_swap_rowf+0x121>
and    $0xfffffffc,%eax
cltq
lea    (%rdi,%rax,4),%rax
lea    0x4(%rdi),%rcx
cmp    %rcx,%rax
mov    %rcx,%r9
cmova  %rax,%r9
mov    %rdi,%r8
not    %r8
add    %r8,%r9
cmp    $0x1c,%r9
jb     1210 <sse_swap_rowf+0x110>
cmp    %rcx,%rax
cmova  %rax,%rcx
lea    0x4(%rsi),%rdx
cmp    %rdi,%rdx
jbe    1162 <sse_swap_rowf+0x62>
add    %r8,%rcx
and    $0xfffffffffffffffc,%rcx
add    %rdi,%rcx
add    $0x4,%rcx
cmp    %rsi,%rcx
ja     1210 <sse_swap_rowf+0x110>
shr    $0x2,%r9
add    $0x1,%r9
mov    %r9,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%r10d
and    $0x3,%r10d
cmp    $0x18,%rcx
jae    1191 <sse_swap_rowf+0x91>
xor    %ecx,%ecx
jmp    11d1 <sse_swap_rowf+0xd1>
and    $0xfffffffffffffffc,%rdx
movss  (%rsi),%xmm0
shufps $0x0,%xmm0,%xmm0
xor    %ecx,%ecx
nop
movups %xmm0,(%rdi,%rcx,4)
movups %xmm0,0x10(%rdi,%rcx,4)
movups %xmm0,0x20(%rdi,%rcx,4)
movups %xmm0,0x30(%rdi,%rcx,4)
movups %xmm0,0x40(%rdi,%rcx,4)
movups %xmm0,0x50(%rdi,%rcx,4)
movups %xmm0,0x60(%rdi,%rcx,4)
movups %xmm0,0x70(%rdi,%rcx,4)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rdx
jne    11a0 <sse_swap_rowf+0xa0>
test   %r10,%r10
je     1202 <sse_swap_rowf+0x102>
movss  (%rsi),%xmm0
shufps $0x0,%xmm0,%xmm0
lea    (%rdi,%rcx,4),%rcx
add    $0x10,%rcx
shl    $0x5,%r10
xor    %edx,%edx
nopl   0x0(%rax)
movups %xmm0,-0x10(%rcx,%rdx,1)
movups %xmm0,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r10
jne    11f0 <sse_swap_rowf+0xf0>
cmp    %r8,%r9
je     1221 <sse_swap_rowf+0x121>
lea    (%rdi,%r8,4),%rdi
nopl   0x0(%rax,%rax,1)
movss  (%rsi),%xmm0
movss  %xmm0,(%rdi)
add    $0x4,%rdi
cmp    %rax,%rdi
jb     1210 <sse_swap_rowf+0x110>
ret

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

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