void arr_float_transpose(float *pDest, float *pSrc, unsigned long int uVectSize,
                         unsigned long int uNVects) {
  unsigned short int v, nv;
  for (nv = 0; nv < uNVects; nv++)
    for (v = 0; v < uVectSize; v++) {
      pDest[uNVects * v + nv] = pSrc[uVectSize * nv + v];
    }
}


x86 assembly (clang, -O0):
<arr_float_transpose>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movw   $0x0,-0x24(%rbp)
movzwl -0x24(%rbp),%eax
cmp    -0x20(%rbp),%rax
jae    119b <arr_float_transpose+0x9b>
movw   $0x0,-0x22(%rbp)
movzwl -0x22(%rbp),%eax
cmp    -0x18(%rbp),%rax
jae    1185 <arr_float_transpose+0x85>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
movzwl -0x24(%rbp),%edx
imul   %rdx,%rcx
movzwl -0x22(%rbp),%edx
add    %rdx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
movzwl -0x22(%rbp),%edx
imul   %rdx,%rcx
movzwl -0x24(%rbp),%edx
add    %rdx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x22(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x22(%rbp)
jmp    112e <arr_float_transpose+0x2e>
jmp    118a <arr_float_transpose+0x8a>
mov    -0x24(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0x24(%rbp)
jmp    111a <arr_float_transpose+0x1a>
pop    %rbp
ret

x86 assembly (clang, -O2):
<arr_float_transpose>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rsi,-0x30(%rsp)
test   %rcx,%rcx
je     12f8 <arr_float_transpose+0x1f8>
mov    %rcx,%r14
lea    -0x1(%rdx),%rax
lea    -0x8(%rdx),%rcx
mov    %rcx,-0x8(%rsp)
shr    $0x3,%rcx
add    $0x1,%rcx
cmp    $0xffff,%ax
sete   %bl
cmp    $0x10000,%rax
setae  %al
or     %bl,%al
cmp    $0x1,%r14
setne  %r10b
or     %al,%r10b
mov    %rdx,%rax
and    $0xfffffffffffffff8,%rax
mov    %rax,-0x18(%rsp)
mov    %rcx,%rax
mov    %rcx,-0x10(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,-0x20(%rsp)
mov    -0x30(%rsp),%r12
lea    0x30(%r12),%r15
lea    0x0(,%rdx,4),%rsi
mov    %r14,%r13
shl    $0x5,%r13
lea    0x10(%rdi),%r8
mov    %r14,%rax
shl    $0x6,%rax
mov    %rax,-0x28(%rsp)
lea    0x0(,%r14,4),%rbp
xor    %r11d,%r11d
mov    %r10b,-0x31(%rsp)
jmp    11cb <arr_float_transpose+0xcb>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r11
movzwl %r11w,%eax
add    %rsi,%r15
add    $0x4,%r8
add    %rsi,%r12
cmp    %r14,%rax
jae    12f8 <arr_float_transpose+0x1f8>
test   %rdx,%rdx
je     11b0 <arr_float_transpose+0xb0>
cmp    $0x8,%rdx
setb   %al
or     %r10b,%al
jne    120a <arr_float_transpose+0x10a>
mov    %r11,%r9
imul   %rdx,%r9
lea    (%r9,%rdx,1),%rax
lea    (%rdi,%r11,4),%rbx
mov    -0x30(%rsp),%rcx
lea    (%rcx,%rax,4),%rax
cmp    %rax,%rbx
jae    123f <arr_float_transpose+0x13f>
lea    (%r11,%rdx,1),%rax
lea    (%rdi,%rax,4),%rax
lea    (%rcx,%r9,4),%rbx
cmp    %rax,%rbx
jae    123f <arr_float_transpose+0x13f>
xor    %eax,%eax
mov    %r14,%rbx
imul   %rax,%rbx
add    $0x1,%rax
add    %r11,%rbx
lea    (%rdi,%rbx,4),%rbx
xchg   %ax,%ax
movss  -0x4(%r12,%rax,4),%xmm0
movss  %xmm0,(%rbx)
movzwl %ax,%ecx
add    $0x1,%rax
add    %rbp,%rbx
cmp    %rdx,%rcx
jb     1220 <arr_float_transpose+0x120>
jmp    11b0 <arr_float_transpose+0xb0>
mov    %rdi,%rbx
mov    %r14,%rcx
cmpq   $0x8,-0x8(%rsp)
jae    1252 <arr_float_transpose+0x152>
xor    %r10d,%r10d
jmp    12a8 <arr_float_transpose+0x1a8>
mov    -0x20(%rsp),%rax
mov    %r8,%r14
xor    %r10d,%r10d
mov    -0x28(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x30(%r15,%r10,4),%xmm0
movups -0x20(%r15,%r10,4),%xmm1
movups %xmm0,-0x10(%r14)
movups %xmm1,(%r14)
movups -0x10(%r15,%r10,4),%xmm0
movups (%r15,%r10,4),%xmm1
movups %xmm0,-0x10(%r14,%r13,1)
movups %xmm1,(%r14,%r13,1)
add    $0x10,%r10
add    %rdi,%r14
add    $0xfffffffffffffffe,%rax
jne    1270 <arr_float_transpose+0x170>
testb  $0x1,-0x10(%rsp)
mov    %rcx,%r14
mov    -0x30(%rsp),%rcx
je     12da <arr_float_transpose+0x1da>
add    %r10,%r9
movups (%rcx,%r9,4),%xmm0
movups 0x10(%rcx,%r9,4),%xmm1
imul   %r14,%r10
add    %r11,%r10
mov    %rbx,%rax
movups %xmm0,(%rbx,%r10,4)
movups %xmm1,0x10(%rbx,%r10,4)
mov    -0x18(%rsp),%rcx
mov    %rcx,%rax
cmp    %rdx,%rcx
mov    %rbx,%rdi
mov    -0x31(%rsp),%r10b
je     11b0 <arr_float_transpose+0xb0>
jmp    120c <arr_float_transpose+0x10c>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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