void netd_flt_absmax_op(void *x, void *y, int nelem) {
  float *a = (float *)x;
  float *b = (float *)y;
  while (nelem--) {
    *a = ((((((*a) > 0) ? (*a) : (-(*a)))) > ((((*b) > 0) ? (*b) : (-(*b)))))
              ? ((((*a) > 0) ? (*a) : (-(*a))))
              : ((((*b) > 0) ? (*b) : (-(*b)))));
    a++;
    b++;
  }
}


x86 assembly (clang, -O0):
<netd_flt_absmax_op>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x14(%rbp)
cmp    $0x0,%eax
je     1293 <netd_flt_absmax_op+0x193>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1159 <netd_flt_absmax_op+0x59>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
jmp    1173 <netd_flt_absmax_op+0x73>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    11a3 <netd_flt_absmax_op+0xa3>
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
jmp    11bd <netd_flt_absmax_op+0xbd>
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x30(%rbp),%xmm0
movss  -0x34(%rbp),%xmm1
ucomiss %xmm1,%xmm0
jbe    121f <netd_flt_absmax_op+0x11f>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    11f6 <netd_flt_absmax_op+0xf6>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
jmp    1210 <netd_flt_absmax_op+0x110>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
jmp    1269 <netd_flt_absmax_op+0x169>
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1245 <netd_flt_absmax_op+0x145>
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
jmp    125f <netd_flt_absmax_op+0x15f>
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x3c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x28(%rbp)
jmp    111f <netd_flt_absmax_op+0x1f>
pop    %rbp
ret

x86 assembly (clang, -O2):
<netd_flt_absmax_op>:
test   %edx,%edx
je     1274 <netd_flt_absmax_op+0x174>
lea    -0x1(%rdx),%r8d
cmp    $0x3,%r8d
jb     1134 <netd_flt_absmax_op+0x34>
lea    (%rsi,%r8,4),%rax
add    $0x4,%rax
cmp    %rdi,%rax
jbe    11be <netd_flt_absmax_op+0xbe>
lea    (%rdi,%r8,4),%rax
add    $0x4,%rax
cmp    %rsi,%rax
jbe    11be <netd_flt_absmax_op+0xbe>
mov    %rsi,%r10
mov    %rdi,%rcx
mov    %edx,%edx
xor    %eax,%eax
movaps 0xebb(%rip),%xmm0
xorps  %xmm8,%xmm8
jmp    1161 <netd_flt_absmax_op+0x61>
nopl   0x0(%rax,%rax,1)
movss  %xmm2,(%rcx,%rax,4)
add    $0x1,%rax
cmp    %eax,%edx
je     1274 <netd_flt_absmax_op+0x174>
movss  (%rcx,%rax,4),%xmm2
movaps %xmm2,%xmm3
xorps  %xmm0,%xmm3
xorps  %xmm6,%xmm6
cmpltss %xmm2,%xmm6
movaps %xmm6,%xmm4
andps  %xmm2,%xmm4
andnps %xmm3,%xmm6
orps   %xmm4,%xmm6
movss  (%r10,%rax,4),%xmm5
movaps %xmm5,%xmm4
xorps  %xmm0,%xmm4
xorps  %xmm7,%xmm7
cmpltss %xmm5,%xmm7
movaps %xmm7,%xmm1
andps  %xmm5,%xmm1
andnps %xmm4,%xmm7
orps   %xmm1,%xmm7
ucomiss %xmm7,%xmm6
jbe    11b0 <netd_flt_absmax_op+0xb0>
ucomiss %xmm8,%xmm2
ja     1150 <netd_flt_absmax_op+0x50>
movaps %xmm3,%xmm2
jmp    1150 <netd_flt_absmax_op+0x50>
ucomiss %xmm8,%xmm5
movaps %xmm5,%xmm2
ja     1150 <netd_flt_absmax_op+0x50>
movaps %xmm4,%xmm2
jmp    1150 <netd_flt_absmax_op+0x50>
add    $0x1,%r8
mov    %r8,%r9
and    $0xfffffffffffffffc,%r9
sub    %r9d,%edx
lea    (%rsi,%r9,4),%r10
lea    (%rdi,%r9,4),%rcx
xor    %eax,%eax
movaps 0xe22(%rip),%xmm8
xchg   %ax,%ax
movups (%rdi,%rax,4),%xmm9
xorps  %xmm4,%xmm4
cmpltps %xmm9,%xmm4
movaps %xmm9,%xmm3
xorps  %xmm8,%xmm3
movaps %xmm4,%xmm2
andnps %xmm3,%xmm2
movaps %xmm9,%xmm5
andps  %xmm4,%xmm5
orps   %xmm2,%xmm5
movups (%rsi,%rax,4),%xmm7
xorps  %xmm6,%xmm6
cmpltps %xmm7,%xmm6
movaps %xmm7,%xmm1
xorps  %xmm8,%xmm1
movaps %xmm6,%xmm0
andnps %xmm1,%xmm0
movaps %xmm7,%xmm2
andps  %xmm6,%xmm2
orps   %xmm0,%xmm2
movaps %xmm2,%xmm0
cmpnltps %xmm5,%xmm0
cmpltps %xmm5,%xmm2
movaps %xmm2,%xmm5
orps   %xmm6,%xmm5
andps  %xmm4,%xmm2
andps  %xmm6,%xmm0
andps  %xmm5,%xmm3
andnps %xmm1,%xmm5
orps   %xmm3,%xmm5
andps  %xmm2,%xmm9
andnps %xmm5,%xmm2
orps   %xmm9,%xmm2
andps  %xmm0,%xmm7
andnps %xmm2,%xmm0
orps   %xmm7,%xmm0
movups %xmm0,(%rdi,%rax,4)
add    $0x4,%rax
cmp    %rax,%r9
jne    11e0 <netd_flt_absmax_op+0xe0>
cmp    %r9,%r8
jne    113a <netd_flt_absmax_op+0x3a>
ret

LLVM IR (-O0):
define void @netd_flt_absmax_op(i8* %0, i8* %1, i32 %2) {
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i32
%7 = alloca float*
%8 = alloca float*
store i8* %0, i8** %4
store i8* %1, i8** %5
store i32 %2, i32* %6
%9 = load i8*, i8** %4
%10 = bitcast i8* %9 to float*
store float* %10, float** %7
%11 = load i8*, i8** %5
%12 = bitcast i8* %11 to float*
store float* %12, float** %8
br label %13
13: ; preds = %69, %3
%14 = load i32, i32* %6
%15 = add nsw i32 %14, -1
store i32 %15, i32* %6
%16 = icmp ne i32 %14, 0
br i1 %16, label %17, label %76
17: ; preds = %13
%18 = load float*, float** %7
%19 = load float, float* %18
%20 = fcmp ogt float %19, 0.000000e+00
br i1 %20, label %21, label %24
21: ; preds = %17
%22 = load float*, float** %7
%23 = load float, float* %22
br label %28
24: ; preds = %17
%25 = load float*, float** %7
%26 = load float, float* %25
%27 = fneg float %26
br label %28
28: ; preds = %24, %21
%29 = phi float [ %23, %21 ], [ %27, %24 ]
%30 = load float*, float** %8
%31 = load float, float* %30
%32 = fcmp ogt float %31, 0.000000e+00
br i1 %32, label %33, label %36
33: ; preds = %28
%34 = load float*, float** %8
%35 = load float, float* %34
br label %40
36: ; preds = %28
%37 = load float*, float** %8
%38 = load float, float* %37
%39 = fneg float %38
br label %40
40: ; preds = %36, %33
%41 = phi float [ %35, %33 ], [ %39, %36 ]
%42 = fcmp ogt float %29, %41
br i1 %42, label %43, label %56
43: ; preds = %40
%44 = load float*, float** %7
%45 = load float, float* %44
%46 = fcmp ogt float %45, 0.000000e+00
br i1 %46, label %47, label %50
47: ; preds = %43
%48 = load float*, float** %7
%49 = load float, float* %48
br label %54
50: ; preds = %43
%51 = load float*, float** %7
%52 = load float, float* %51
%53 = fneg float %52
br label %54
54: ; preds = %50, %47
%55 = phi float [ %49, %47 ], [ %53, %50 ]
br label %69
56: ; preds = %40
%57 = load float*, float** %8
%58 = load float, float* %57
%59 = fcmp ogt float %58, 0.000000e+00
br i1 %59, label %60, label %63
60: ; preds = %56
%61 = load float*, float** %8
%62 = load float, float* %61
br label %67
63: ; preds = %56
%64 = load float*, float** %8
%65 = load float, float* %64
%66 = fneg float %65
br label %67
67: ; preds = %63, %60
%68 = phi float [ %62, %60 ], [ %66, %63 ]
br label %69
69: ; preds = %67, %54
%70 = phi float [ %55, %54 ], [ %68, %67 ]
%71 = load float*, float** %7
store float %70, float* %71
%72 = load float*, float** %7
%73 = getelementptr inbounds float, float* %72, i32 1
store float* %73, float** %7
%74 = load float*, float** %8
%75 = getelementptr inbounds float, float* %74, i32 1
store float* %75, float** %8
br label %13
76: ; preds = %13
ret void
}

LLVM IR (-O2):
define void @netd_flt_absmax_op(i8* nocapture %0, i8* nocapture %1, i32 %2) {
%4 = icmp eq i32 %2, 0
br i1 %4, label %82, label %5
5: ; preds = %3
%6 = bitcast i8* %1 to float*
%7 = bitcast i8* %0 to float*
%8 = add i32 %2, -1
%9 = zext i32 %8 to i64
%10 = add nuw nsw i64 %9, 1
%11 = icmp ult i32 %8, 3
br i1 %11, label %55, label %12
12: ; preds = %5
%13 = add i32 %2, -1
%14 = zext i32 %13 to i64
%15 = shl nuw nsw i64 %14, 2
%16 = add nuw nsw i64 %15, 4
%17 = getelementptr i8, i8* %0, i64 %16
%18 = getelementptr i8, i8* %1, i64 %16
%19 = icmp ugt i8* %18, %0
%20 = icmp ugt i8* %17, %1
%21 = and i1 %19, %20
br i1 %21, label %55, label %22
22: ; preds = %12
%23 = and i64 %10, 8589934588
%24 = trunc i64 %23 to i32
%25 = sub i32 %2, %24
%26 = getelementptr float, float* %6, i64 %23
%27 = getelementptr float, float* %7, i64 %23
br label %28
28: ; preds = %28, %22
%29 = phi i64 [ 0, %22 ], [ %51, %28 ]
%30 = getelementptr float, float* %6, i64 %29
%31 = getelementptr float, float* %7, i64 %29
%32 = bitcast float* %31 to <4 x float>*
%33 = load <4 x float>, <4 x float>* %32
%34 = fcmp ogt <4 x float> %33, zeroinitializer
%35 = fneg <4 x float> %33
%36 = select <4 x i1> %34, <4 x float> %33, <4 x float> %35
%37 = bitcast float* %30 to <4 x float>*
%38 = load <4 x float>, <4 x float>* %37
%39 = fcmp ogt <4 x float> %38, zeroinitializer
%40 = fneg <4 x float> %38
%41 = select <4 x i1> %39, <4 x float> %38, <4 x float> %40
%42 = fcmp ogt <4 x float> %36, %41
%43 = xor <4 x i1> %42, <i1 true, i1 true, i1 true, i1 true>
%44 = or <4 x i1> %42, %39
%45 = and <4 x i1> %42, %34
%46 = select <4 x i1> %43, <4 x i1> %39, <4 x i1> zeroinitializer
%47 = select <4 x i1> %44, <4 x float> %35, <4 x float> %40
%48 = select <4 x i1> %45, <4 x float> %33, <4 x float> %47
%49 = select <4 x i1> %46, <4 x float> %38, <4 x float> %48
%50 = bitcast float* %31 to <4 x float>*
store <4 x float> %49, <4 x float>* %50
%51 = add nuw i64 %29, 4
%52 = icmp eq i64 %51, %23
br i1 %52, label %53, label %28
53: ; preds = %28
%54 = icmp eq i64 %10, %23
br i1 %54, label %82, label %55
55: ; preds = %12, %5, %53
%56 = phi i32 [ %2, %12 ], [ %2, %5 ], [ %25, %53 ]
%57 = phi float* [ %6, %12 ], [ %6, %5 ], [ %26, %53 ]
%58 = phi float* [ %7, %12 ], [ %7, %5 ], [ %27, %53 ]
br label %59
59: ; preds = %55, %77
%60 = phi i32 [ %63, %77 ], [ %56, %55 ]
%61 = phi float* [ %80, %77 ], [ %57, %55 ]
%62 = phi float* [ %79, %77 ], [ %58, %55 ]
%63 = add nsw i32 %60, -1
%64 = load float, float* %62
%65 = fcmp ogt float %64, 0.000000e+00
%66 = fneg float %64
%67 = select i1 %65, float %64, float %66
%68 = load float, float* %61
%69 = fcmp ogt float %68, 0.000000e+00
%70 = fneg float %68
%71 = select i1 %69, float %68, float %70
%72 = fcmp ogt float %67, %71
br i1 %72, label %73, label %75
73: ; preds = %59
br i1 %65, label %77, label %74
74: ; preds = %73
br label %77
75: ; preds = %59
br i1 %69, label %77, label %76
76: ; preds = %75
br label %77
77: ; preds = %75, %73, %76, %74
%78 = phi float [ %66, %74 ], [ %70, %76 ], [ %64, %73 ], [ %68, %75 ]
store float %78, float* %62
%79 = getelementptr inbounds float, float* %62, i64 1
%80 = getelementptr inbounds float, float* %61, i64 1
%81 = icmp eq i32 %63, 0
br i1 %81, label %82, label %59
82: ; preds = %77, %53, %3
ret void
}