int swapBytes(float *buffer, long bufsize) {
  float *bufpos;
  char ctmp;
  unsigned short itmp;
  union {
    char cval[4];
    unsigned short ival[2];
    float fval;
  } bufval;
  bufpos = buffer;
  while (bufpos < buffer + bufsize) {
    bufval.fval = *bufpos;
    ctmp = bufval.cval[0];
    bufval.cval[0] = bufval.cval[1];
    bufval.cval[1] = ctmp;
    ctmp = bufval.cval[2];
    bufval.cval[2] = bufval.cval[3];
    bufval.cval[3] = ctmp;
    itmp = bufval.ival[0];
    bufval.ival[0] = bufval.ival[1];
    bufval.ival[1] = itmp;
    *bufpos = bufval.fval;
    bufpos++;
  }
  return (0);
}


x86 assembly (clang, -O0):
<swapBytes>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x10(%rbp),%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jae    1197 <swapBytes+0x97>
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x20(%rbp),%al
mov    %al,-0x19(%rbp)
mov    -0x1f(%rbp),%al
mov    %al,-0x20(%rbp)
mov    -0x19(%rbp),%al
mov    %al,-0x1f(%rbp)
mov    -0x1e(%rbp),%al
mov    %al,-0x19(%rbp)
mov    -0x1d(%rbp),%al
mov    %al,-0x1e(%rbp)
mov    -0x19(%rbp),%al
mov    %al,-0x1d(%rbp)
mov    -0x20(%rbp),%ax
mov    %ax,-0x1c(%rbp)
mov    -0x1e(%rbp),%ax
mov    %ax,-0x20(%rbp)
mov    -0x1c(%rbp),%ax
mov    %ax,-0x1e(%rbp)
movss  -0x20(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x18(%rbp)
jmp    1114 <swapBytes+0x14>
xor    %eax,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<swapBytes>:
test   %rsi,%rsi
jle    11cf <swapBytes+0xcf>
lea    (%rdi,%rsi,4),%rax
lea    0x4(%rdi),%rcx
cmp    %rcx,%rax
cmova  %rax,%rcx
mov    %rdi,%r8
not    %r8
add    %rcx,%r8
cmp    $0x1c,%r8
jae    112f <swapBytes+0x2f>
mov    %rdi,%rcx
jmp    11c0 <swapBytes+0xc0>
shr    $0x2,%r8
add    $0x1,%r8
mov    %r8,%rsi
and    $0xfffffffffffffff8,%rsi
lea    (%rdi,%rsi,4),%rcx
xor    %edx,%edx
pxor   %xmm0,%xmm0
nopl   0x0(%rax,%rax,1)
movdqu (%rdi,%rdx,4),%xmm1
movdqu 0x10(%rdi,%rdx,4),%xmm2
movdqa %xmm1,%xmm3
punpckhbw %xmm0,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpcklbw %xmm0,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqa %xmm2,%xmm3
punpckhbw %xmm0,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpcklbw %xmm0,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqu %xmm1,(%rdi,%rdx,4)
movdqu %xmm2,0x10(%rdi,%rdx,4)
add    $0x8,%rdx
cmp    %rdx,%rsi
jne    1150 <swapBytes+0x50>
cmp    %rsi,%r8
je     11cf <swapBytes+0xcf>
nopl   0x0(%rax)
mov    (%rcx),%edx
bswap  %edx
mov    %edx,(%rcx)
add    $0x4,%rcx
cmp    %rax,%rcx
jb     11c0 <swapBytes+0xc0>
xor    %eax,%eax
ret

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

LLVM IR (-O2):
define i32 @swapBytes(float* %0, i64 %1) {
%3 = ptrtoint float* %0 to i64
%4 = getelementptr inbounds float, float* %0, i64 %1
%5 = icmp sgt i64 %1, 0
br i1 %5, label %6, label %44
6: ; preds = %2
%7 = shl i64 %1, 2
%8 = add i64 %7, %3
%9 = add i64 %3, 4
%10 = call i64 @llvm.umax.i64(i64 %8, i64 %9)
%11 = xor i64 %3, -1
%12 = add i64 %10, %11
%13 = lshr i64 %12, 2
%14 = add nuw nsw i64 %13, 1
%15 = icmp ult i64 %12, 28
br i1 %15, label %35, label %16
16: ; preds = %6
%17 = and i64 %14, 9223372036854775800
%18 = getelementptr float, float* %0, i64 %17
br label %19
19: ; preds = %19, %16
%20 = phi i64 [ 0, %16 ], [ %31, %19 ]
%21 = getelementptr float, float* %0, i64 %20
%22 = bitcast float* %21 to <4 x i32>*
%23 = load <4 x i32>, <4 x i32>* %22
%24 = getelementptr float, float* %21, i64 4
%25 = bitcast float* %24 to <4 x i32>*
%26 = load <4 x i32>, <4 x i32>* %25
%27 = call <4 x i32> @llvm.bswap.v4i32(<4 x i32> %23)
%28 = call <4 x i32> @llvm.bswap.v4i32(<4 x i32> %26)
%29 = bitcast float* %21 to <4 x i32>*
store <4 x i32> %27, <4 x i32>* %29
%30 = bitcast float* %24 to <4 x i32>*
store <4 x i32> %28, <4 x i32>* %30
%31 = add nuw i64 %20, 8
%32 = icmp eq i64 %31, %17
br i1 %32, label %33, label %19
33: ; preds = %19
%34 = icmp eq i64 %14, %17
br i1 %34, label %44, label %35
35: ; preds = %6, %33
%36 = phi float* [ %0, %6 ], [ %18, %33 ]
br label %37
37: ; preds = %35, %37
%38 = phi float* [ %42, %37 ], [ %36, %35 ]
%39 = bitcast float* %38 to i32*
%40 = load i32, i32* %39
%41 = tail call i32 @llvm.bswap.i32(i32 %40)
store i32 %41, i32* %39
%42 = getelementptr inbounds float, float* %38, i64 1
%43 = icmp ult float* %42, %4
br i1 %43, label %37, label %44
44: ; preds = %37, %33, %2
ret i32 0
}