void kernel_CPU_srcVet_3D(float *cpu_U1, float *cpu_V, int ind, int *ind_SrcI,
                          int *ind_SrcJ, int *ind_SrcK, float val, float fat,
                          int NNOI, int NNOJ) {
  unsigned long int i =
      ind_SrcK[ind] * NNOI * NNOJ + ind_SrcJ[ind] * NNOI + ind_SrcI[ind];
  float v = cpu_V[i];
  cpu_U1[i] += fat * v * v * val;
}


x86 assembly (clang, -O0):
<kernel_CPU_srcVet_3D>:
push   %rbp
mov    %rsp,%rbp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movss  %xmm0,-0x34(%rbp)
movss  %xmm1,-0x38(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
imul   0x10(%rbp),%eax
imul   0x18(%rbp),%eax
mov    -0x28(%rbp),%rcx
movslq -0x14(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
imul   0x10(%rbp),%ecx
add    %ecx,%eax
mov    -0x20(%rbp),%rcx
movslq -0x14(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
cltq
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x38(%rbp),%xmm0
mulss  -0x44(%rbp),%xmm0
mulss  -0x44(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel_CPU_srcVet_3D>:
movslq %edx,%rax
mov    (%r9,%rax,4),%edx
imul   0x10(%rsp),%edx
add    (%r8,%rax,4),%edx
imul   0x8(%rsp),%edx
add    (%rcx,%rax,4),%edx
movslq %edx,%rax
movss  (%rsi,%rax,4),%xmm2
mulss  %xmm2,%xmm1
mulss  %xmm2,%xmm1
mulss  %xmm0,%xmm1
addss  (%rdi,%rax,4),%xmm1
movss  %xmm1,(%rdi,%rax,4)
ret

LLVM IR (-O0):
define void @kernel_CPU_srcVet_3D(float* %0, float* %1, i32 %2, i32* %3, i32* %4, i32* %5, float %6, float %7, i32 %8, i32 %9) {
%11 = alloca float*
%12 = alloca float*
%13 = alloca i32
%14 = alloca i32*
%15 = alloca i32*
%16 = alloca i32*
%17 = alloca float
%18 = alloca float
%19 = alloca i32
%20 = alloca i32
%21 = alloca i64
%22 = alloca float
store float* %0, float** %11
store float* %1, float** %12
store i32 %2, i32* %13
store i32* %3, i32** %14
store i32* %4, i32** %15
store i32* %5, i32** %16
store float %6, float* %17
store float %7, float* %18
store i32 %8, i32* %19
store i32 %9, i32* %20
%23 = load i32*, i32** %16
%24 = load i32, i32* %13
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds i32, i32* %23, i64 %25
%27 = load i32, i32* %26
%28 = load i32, i32* %19
%29 = mul nsw i32 %27, %28
%30 = load i32, i32* %20
%31 = mul nsw i32 %29, %30
%32 = load i32*, i32** %15
%33 = load i32, i32* %13
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds i32, i32* %32, i64 %34
%36 = load i32, i32* %35
%37 = load i32, i32* %19
%38 = mul nsw i32 %36, %37
%39 = add nsw i32 %31, %38
%40 = load i32*, i32** %14
%41 = load i32, i32* %13
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds i32, i32* %40, i64 %42
%44 = load i32, i32* %43
%45 = add nsw i32 %39, %44
%46 = sext i32 %45 to i64
store i64 %46, i64* %21
%47 = load float*, float** %12
%48 = load i64, i64* %21
%49 = getelementptr inbounds float, float* %47, i64 %48
%50 = load float, float* %49
store float %50, float* %22
%51 = load float, float* %18
%52 = load float, float* %22
%53 = fmul float %51, %52
%54 = load float, float* %22
%55 = fmul float %53, %54
%56 = load float, float* %17
%57 = load float*, float** %11
%58 = load i64, i64* %21
%59 = getelementptr inbounds float, float* %57, i64 %58
%60 = load float, float* %59
%61 = call float @llvm.fmuladd.f32(float %55, float %56, float %60)
store float %61, float* %59
ret void
}

LLVM IR (-O2):
define void @kernel_CPU_srcVet_3D(float* nocapture %0, float* nocapture %1, i32 %2, i32* nocapture %3, i32* nocapture %4, i32* nocapture %5, float %6, float %7, i32 %8, i32 %9) {
%11 = sext i32 %2 to i64
%12 = getelementptr inbounds i32, i32* %5, i64 %11
%13 = load i32, i32* %12
%14 = mul i32 %13, %9
%15 = getelementptr inbounds i32, i32* %4, i64 %11
%16 = load i32, i32* %15
%17 = getelementptr inbounds i32, i32* %3, i64 %11
%18 = load i32, i32* %17
%19 = add i32 %14, %16
%20 = mul i32 %19, %8
%21 = add i32 %20, %18
%22 = sext i32 %21 to i64
%23 = getelementptr inbounds float, float* %1, i64 %22
%24 = load float, float* %23
%25 = fmul float %24, %7
%26 = fmul float %24, %25
%27 = getelementptr inbounds float, float* %0, i64 %22
%28 = load float, float* %27
%29 = tail call float @llvm.fmuladd.f32(float %26, float %6, float %28)
store float %29, float* %27
ret void
}