void h3(float *c, float *a, float *b, int size) {
#pragma omp simd
  for (int i = 0; i < size; ++i) {
    for (int j = 0; j < size; ++j) {
      c[j * i] = a[i] * b[j];
    }
  }
}


x86 assembly (clang, -O0):
<h3>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1187 <h3+0x87>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1174 <h3+0x74>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x20(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    112d <h3+0x2d>
jmp    1179 <h3+0x79>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    111a <h3+0x1a>
pop    %rbp
ret

x86 assembly (clang, -O2):
<h3>:
push   %r14
push   %rbx
test   %ecx,%ecx
jle    1199 <h3+0x99>
mov    %ecx,%r8d
mov    %r8d,%r9d
and    $0xfffffffe,%r9d
xor    %r10d,%r10d
xor    %r11d,%r11d
xor    %r14d,%r14d
jmp    1131 <h3+0x31>
add    $0x1,%r14
add    $0x4,%r11
add    $0x8,%r10
cmp    %r8,%r14
je     1199 <h3+0x99>
cmp    $0x1,%ecx
jne    1140 <h3+0x40>
xor    %ebx,%ebx
jmp    117d <h3+0x7d>
nopw   0x0(%rax,%rax,1)
mov    %rdi,%rax
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rsi,%r14,4),%xmm0
mulss  (%rdx,%rbx,4),%xmm0
movss  %xmm0,(%rax)
movss  (%rsi,%r14,4),%xmm0
mulss  0x4(%rdx,%rbx,4),%xmm0
movss  %xmm0,(%rax,%r11,1)
add    $0x2,%rbx
add    %r10,%rax
cmp    %rbx,%r9
jne    1150 <h3+0x50>
test   $0x1,%r8b
je     1120 <h3+0x20>
movss  (%rsi,%r14,4),%xmm0
mulss  (%rdx,%rbx,4),%xmm0
imul   %r14,%rbx
movss  %xmm0,(%rdi,%rbx,4)
jmp    1120 <h3+0x20>
pop    %rbx
pop    %r14
ret

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

LLVM IR (-O2):
define void @h3(float* nocapture writeonly %0, float* nocapture %1, float* nocapture %2, i32 %3) {
%5 = icmp sgt i32 %3, 0
br i1 %5, label %6, label %15
6: ; preds = %4
%7 = zext i32 %3 to i64
%8 = and i64 %7, 1
%9 = icmp eq i32 %3, 1
%10 = and i64 %7, 4294967294
%11 = icmp eq i64 %8, 0
br label %12
12: ; preds = %25, %6
%13 = phi i64 [ 0, %6 ], [ %26, %25 ]
%14 = getelementptr inbounds float, float* %1, i64 %13
br i1 %9, label %16, label %28
15: ; preds = %25, %4
ret void
16: ; preds = %28, %12
%17 = phi i64 [ 0, %12 ], [ %44, %28 ]
br i1 %11, label %25, label %18
18: ; preds = %16
%19 = load float, float* %14
%20 = getelementptr inbounds float, float* %2, i64 %17
%21 = load float, float* %20
%22 = fmul float %19, %21
%23 = mul nuw nsw i64 %17, %13
%24 = getelementptr inbounds float, float* %0, i64 %23
store float %22, float* %24
br label %25
25: ; preds = %16, %18
%26 = add nuw nsw i64 %13, 1
%27 = icmp eq i64 %26, %7
br i1 %27, label %15, label %12
28: ; preds = %12, %28
%29 = phi i64 [ %44, %28 ], [ 0, %12 ]
%30 = phi i64 [ %45, %28 ], [ 0, %12 ]
%31 = load float, float* %14
%32 = getelementptr inbounds float, float* %2, i64 %29
%33 = load float, float* %32
%34 = fmul float %31, %33
%35 = mul nuw nsw i64 %29, %13
%36 = getelementptr inbounds float, float* %0, i64 %35
store float %34, float* %36
%37 = or i64 %29, 1
%38 = load float, float* %14
%39 = getelementptr inbounds float, float* %2, i64 %37
%40 = load float, float* %39
%41 = fmul float %38, %40
%42 = mul nuw nsw i64 %37, %13
%43 = getelementptr inbounds float, float* %0, i64 %42
store float %41, float* %43
%44 = add nuw nsw i64 %29, 2
%45 = add i64 %30, 2
%46 = icmp eq i64 %45, %10
br i1 %46, label %16, label %28
}