void transpose_matrix08(float **m, long nrow, long ncol, float **transposed) {
  long i, j;
  float m0, m1, m2, m3, m4, m5, m6, m7;
  float *pm;
  for (i = 0; i < nrow; i++) {
    pm = m[i];
    for (j = 0; j < ncol; j++) {
      m0 = *pm++;
      m1 = *pm++;
      m2 = *pm++;
      m3 = *pm++;
      m4 = *pm++;
      m5 = *pm++;
      m6 = *pm++;
      m7 = *pm++;
      transposed[j++][i] = m0;
      transposed[j++][i] = m1;
      transposed[j++][i] = m2;
      transposed[j++][i] = m3;
      transposed[j++][i] = m4;
      transposed[j++][i] = m5;
      transposed[j++][i] = m6;
      transposed[j][i] = m7;
    }
  }
}


x86 assembly (clang, -O0):
<transpose_matrix08>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movq   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    1354 <transpose_matrix08+0x254>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x58(%rbp)
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    133e <transpose_matrix08+0x23e>
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x58(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x58(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x58(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x58(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x58(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x58(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x58(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x58(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x34(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x38(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x40(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x44(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x4c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1142 <transpose_matrix08+0x42>
jmp    1343 <transpose_matrix08+0x243>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    111c <transpose_matrix08+0x1c>
pop    %rbp
ret

x86 assembly (clang, -O2):
<transpose_matrix08>:
test   %rsi,%rsi
jle    11d0 <transpose_matrix08+0xd0>
xor    %r8d,%r8d
jmp    111d <transpose_matrix08+0x1d>
xchg   %ax,%ax
add    $0x1,%r8
cmp    %rsi,%r8
je     11d0 <transpose_matrix08+0xd0>
test   %rdx,%rdx
jle    1110 <transpose_matrix08+0x10>
mov    (%rdi,%r8,8),%r9
xor    %r10d,%r10d
nopl   0x0(%rax)
movss  (%r9,%r10,4),%xmm0
movss  0x4(%r9,%r10,4),%xmm1
movss  0x8(%r9,%r10,4),%xmm2
movss  0xc(%r9,%r10,4),%xmm3
movss  0x10(%r9,%r10,4),%xmm4
movss  0x14(%r9,%r10,4),%xmm5
movss  0x18(%r9,%r10,4),%xmm6
movss  0x1c(%r9,%r10,4),%xmm7
mov    (%rcx,%r10,8),%rax
movss  %xmm0,(%rax,%r8,4)
mov    0x8(%rcx,%r10,8),%rax
movss  %xmm1,(%rax,%r8,4)
mov    0x10(%rcx,%r10,8),%rax
movss  %xmm2,(%rax,%r8,4)
mov    0x18(%rcx,%r10,8),%rax
movss  %xmm3,(%rax,%r8,4)
mov    0x20(%rcx,%r10,8),%rax
movss  %xmm4,(%rax,%r8,4)
mov    0x28(%rcx,%r10,8),%rax
movss  %xmm5,(%rax,%r8,4)
mov    0x30(%rcx,%r10,8),%rax
movss  %xmm6,(%rax,%r8,4)
mov    0x38(%rcx,%r10,8),%rax
movss  %xmm7,(%rax,%r8,4)
add    $0x8,%r10
cmp    %rdx,%r10
jl     1130 <transpose_matrix08+0x30>
jmp    1110 <transpose_matrix08+0x10>
ret

LLVM IR (-O0):
define void @transpose_matrix08(float** %0, i64 %1, i64 %2, float** %3) {
%5 = alloca float**
%6 = alloca i64
%7 = alloca i64
%8 = alloca float**
%9 = alloca i64
%10 = alloca i64
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float*
store float** %0, float*** %5
store i64 %1, i64* %6
store i64 %2, i64* %7
store float** %3, float*** %8
store i64 0, i64* %9
br label %20
20: ; preds = %125, %4
%21 = load i64, i64* %9
%22 = load i64, i64* %6
%23 = icmp slt i64 %21, %22
br i1 %23, label %24, label %128
24: ; preds = %20
%25 = load float**, float*** %5
%26 = load i64, i64* %9
%27 = getelementptr inbounds float*, float** %25, i64 %26
%28 = load float*, float** %27
store float* %28, float** %19
store i64 0, i64* %10
br label %29
29: ; preds = %121, %24
%30 = load i64, i64* %10
%31 = load i64, i64* %7
%32 = icmp slt i64 %30, %31
br i1 %32, label %33, label %124
33: ; preds = %29
%34 = load float*, float** %19
%35 = getelementptr inbounds float, float* %34, i32 1
store float* %35, float** %19
%36 = load float, float* %34
store float %36, float* %11
%37 = load float*, float** %19
%38 = getelementptr inbounds float, float* %37, i32 1
store float* %38, float** %19
%39 = load float, float* %37
store float %39, float* %12
%40 = load float*, float** %19
%41 = getelementptr inbounds float, float* %40, i32 1
store float* %41, float** %19
%42 = load float, float* %40
store float %42, float* %13
%43 = load float*, float** %19
%44 = getelementptr inbounds float, float* %43, i32 1
store float* %44, float** %19
%45 = load float, float* %43
store float %45, float* %14
%46 = load float*, float** %19
%47 = getelementptr inbounds float, float* %46, i32 1
store float* %47, float** %19
%48 = load float, float* %46
store float %48, float* %15
%49 = load float*, float** %19
%50 = getelementptr inbounds float, float* %49, i32 1
store float* %50, float** %19
%51 = load float, float* %49
store float %51, float* %16
%52 = load float*, float** %19
%53 = getelementptr inbounds float, float* %52, i32 1
store float* %53, float** %19
%54 = load float, float* %52
store float %54, float* %17
%55 = load float*, float** %19
%56 = getelementptr inbounds float, float* %55, i32 1
store float* %56, float** %19
%57 = load float, float* %55
store float %57, float* %18
%58 = load float, float* %11
%59 = load float**, float*** %8
%60 = load i64, i64* %10
%61 = add nsw i64 %60, 1
store i64 %61, i64* %10
%62 = getelementptr inbounds float*, float** %59, i64 %60
%63 = load float*, float** %62
%64 = load i64, i64* %9
%65 = getelementptr inbounds float, float* %63, i64 %64
store float %58, float* %65
%66 = load float, float* %12
%67 = load float**, float*** %8
%68 = load i64, i64* %10
%69 = add nsw i64 %68, 1
store i64 %69, i64* %10
%70 = getelementptr inbounds float*, float** %67, i64 %68
%71 = load float*, float** %70
%72 = load i64, i64* %9
%73 = getelementptr inbounds float, float* %71, i64 %72
store float %66, float* %73
%74 = load float, float* %13
%75 = load float**, float*** %8
%76 = load i64, i64* %10
%77 = add nsw i64 %76, 1
store i64 %77, i64* %10
%78 = getelementptr inbounds float*, float** %75, i64 %76
%79 = load float*, float** %78
%80 = load i64, i64* %9
%81 = getelementptr inbounds float, float* %79, i64 %80
store float %74, float* %81
%82 = load float, float* %14
%83 = load float**, float*** %8
%84 = load i64, i64* %10
%85 = add nsw i64 %84, 1
store i64 %85, i64* %10
%86 = getelementptr inbounds float*, float** %83, i64 %84
%87 = load float*, float** %86
%88 = load i64, i64* %9
%89 = getelementptr inbounds float, float* %87, i64 %88
store float %82, float* %89
%90 = load float, float* %15
%91 = load float**, float*** %8
%92 = load i64, i64* %10
%93 = add nsw i64 %92, 1
store i64 %93, i64* %10
%94 = getelementptr inbounds float*, float** %91, i64 %92
%95 = load float*, float** %94
%96 = load i64, i64* %9
%97 = getelementptr inbounds float, float* %95, i64 %96
store float %90, float* %97
%98 = load float, float* %16
%99 = load float**, float*** %8
%100 = load i64, i64* %10
%101 = add nsw i64 %100, 1
store i64 %101, i64* %10
%102 = getelementptr inbounds float*, float** %99, i64 %100
%103 = load float*, float** %102
%104 = load i64, i64* %9
%105 = getelementptr inbounds float, float* %103, i64 %104
store float %98, float* %105
%106 = load float, float* %17
%107 = load float**, float*** %8
%108 = load i64, i64* %10
%109 = add nsw i64 %108, 1
store i64 %109, i64* %10
%110 = getelementptr inbounds float*, float** %107, i64 %108
%111 = load float*, float** %110
%112 = load i64, i64* %9
%113 = getelementptr inbounds float, float* %111, i64 %112
store float %106, float* %113
%114 = load float, float* %18
%115 = load float**, float*** %8
%116 = load i64, i64* %10
%117 = getelementptr inbounds float*, float** %115, i64 %116
%118 = load float*, float** %117
%119 = load i64, i64* %9
%120 = getelementptr inbounds float, float* %118, i64 %119
store float %114, float* %120
br label %121
121: ; preds = %33
%122 = load i64, i64* %10
%123 = add nsw i64 %122, 1
store i64 %123, i64* %10
br label %29
124: ; preds = %29
br label %125
125: ; preds = %124
%126 = load i64, i64* %9
%127 = add nsw i64 %126, 1
store i64 %127, i64* %9
br label %20
128: ; preds = %20
ret void
}

LLVM IR (-O2):
define void @transpose_matrix08(float** nocapture %0, i64 %1, i64 %2, float** nocapture %3) {
%5 = icmp sgt i64 %1, 0
br i1 %5, label %6, label %68
6: ; preds = %4
%7 = icmp sgt i64 %2, 0
br label %8
8: ; preds = %6, %65
%9 = phi i64 [ 0, %6 ], [ %66, %65 ]
br i1 %7, label %10, label %65
10: ; preds = %8
%11 = getelementptr inbounds float*, float** %0, i64 %9
%12 = load float*, float** %11
br label %13
13: ; preds = %10, %13
%14 = phi float* [ %30, %13 ], [ %12, %10 ]
%15 = phi i64 [ %63, %13 ], [ 0, %10 ]
%16 = getelementptr inbounds float, float* %14, i64 1
%17 = load float, float* %14
%18 = getelementptr inbounds float, float* %14, i64 2
%19 = load float, float* %16
%20 = getelementptr inbounds float, float* %14, i64 3
%21 = load float, float* %18
%22 = getelementptr inbounds float, float* %14, i64 4
%23 = load float, float* %20
%24 = getelementptr inbounds float, float* %14, i64 5
%25 = load float, float* %22
%26 = getelementptr inbounds float, float* %14, i64 6
%27 = load float, float* %24
%28 = getelementptr inbounds float, float* %14, i64 7
%29 = load float, float* %26
%30 = getelementptr inbounds float, float* %14, i64 8
%31 = load float, float* %28
%32 = or i64 %15, 1
%33 = getelementptr inbounds float*, float** %3, i64 %15
%34 = load float*, float** %33
%35 = getelementptr inbounds float, float* %34, i64 %9
store float %17, float* %35
%36 = or i64 %15, 2
%37 = getelementptr inbounds float*, float** %3, i64 %32
%38 = load float*, float** %37
%39 = getelementptr inbounds float, float* %38, i64 %9
store float %19, float* %39
%40 = or i64 %15, 3
%41 = getelementptr inbounds float*, float** %3, i64 %36
%42 = load float*, float** %41
%43 = getelementptr inbounds float, float* %42, i64 %9
store float %21, float* %43
%44 = or i64 %15, 4
%45 = getelementptr inbounds float*, float** %3, i64 %40
%46 = load float*, float** %45
%47 = getelementptr inbounds float, float* %46, i64 %9
store float %23, float* %47
%48 = or i64 %15, 5
%49 = getelementptr inbounds float*, float** %3, i64 %44
%50 = load float*, float** %49
%51 = getelementptr inbounds float, float* %50, i64 %9
store float %25, float* %51
%52 = or i64 %15, 6
%53 = getelementptr inbounds float*, float** %3, i64 %48
%54 = load float*, float** %53
%55 = getelementptr inbounds float, float* %54, i64 %9
store float %27, float* %55
%56 = or i64 %15, 7
%57 = getelementptr inbounds float*, float** %3, i64 %52
%58 = load float*, float** %57
%59 = getelementptr inbounds float, float* %58, i64 %9
store float %29, float* %59
%60 = getelementptr inbounds float*, float** %3, i64 %56
%61 = load float*, float** %60
%62 = getelementptr inbounds float, float* %61, i64 %9
store float %31, float* %62
%63 = add nuw nsw i64 %15, 8
%64 = icmp slt i64 %63, %2
br i1 %64, label %13, label %65
65: ; preds = %13, %8
%66 = add nuw nsw i64 %9, 1
%67 = icmp eq i64 %66, %1
br i1 %67, label %68, label %8
68: ; preds = %65, %4
ret void
}