int multiply(void *data, int n) {
  int *tab1 = data;
  int *tab2 = tab1 + n;
  int vector = 0;
  int i;
  for (i = 0; i < n; i++) {
    vector += tab1[i] * tab2[i];
  }
  return vector;
}


x86 assembly (clang, -O0):
<multiply>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
movslq -0xc(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    116b <multiply+0x6b>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x20(%rbp),%rcx
movslq -0x28(%rbp),%rdx
imul   (%rcx,%rdx,4),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1134 <multiply+0x34>
mov    -0x24(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<multiply>:
test   %esi,%esi
jle    111c <multiply+0x1c>
movslq %esi,%rax
lea    (%rdi,%rax,4),%r9
mov    %esi,%r10d
cmp    $0x8,%esi
jae    111f <multiply+0x1f>
xor    %esi,%esi
xor    %eax,%eax
jmp    12c0 <multiply+0x1c0>
xor    %eax,%eax
ret
mov    %r10d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rcx
mov    %rcx,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     12d4 <multiply+0x1d4>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
lea    0x30(%rdi),%r11
lea    (%rdi,%rax,4),%rdx
add    $0x30,%rdx
pxor   %xmm0,%xmm0
xor    %eax,%eax
pxor   %xmm1,%xmm1
nopw   0x0(%rax,%rax,1)
movdqu -0x30(%r11,%rax,4),%xmm5
movdqu -0x20(%r11,%rax,4),%xmm10
movdqu -0x10(%r11,%rax,4),%xmm9
movdqu (%r11,%rax,4),%xmm8
movdqu -0x30(%rdx,%rax,4),%xmm7
movdqu -0x20(%rdx,%rax,4),%xmm2
movdqu -0x10(%rdx,%rax,4),%xmm4
movdqu (%rdx,%rax,4),%xmm3
pshufd $0xf5,%xmm7,%xmm6
pmuludq %xmm5,%xmm7
pshufd $0xe8,%xmm7,%xmm7
pshufd $0xf5,%xmm5,%xmm5
pmuludq %xmm6,%xmm5
pshufd $0xe8,%xmm5,%xmm5
punpckldq %xmm5,%xmm7
paddd  %xmm0,%xmm7
pshufd $0xf5,%xmm2,%xmm0
pmuludq %xmm10,%xmm2
pshufd $0xe8,%xmm2,%xmm2
pshufd $0xf5,%xmm10,%xmm5
pmuludq %xmm0,%xmm5
pshufd $0xe8,%xmm5,%xmm0
punpckldq %xmm0,%xmm2
paddd  %xmm1,%xmm2
pshufd $0xf5,%xmm4,%xmm1
pmuludq %xmm9,%xmm4
pshufd $0xe8,%xmm4,%xmm0
pshufd $0xf5,%xmm9,%xmm4
pmuludq %xmm1,%xmm4
pshufd $0xe8,%xmm4,%xmm1
punpckldq %xmm1,%xmm0
paddd  %xmm7,%xmm0
pshufd $0xf5,%xmm3,%xmm4
pmuludq %xmm8,%xmm3
pshufd $0xe8,%xmm3,%xmm1
pshufd $0xf5,%xmm8,%xmm3
pmuludq %xmm4,%xmm3
pshufd $0xe8,%xmm3,%xmm3
punpckldq %xmm3,%xmm1
paddd  %xmm2,%xmm1
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    1160 <multiply+0x60>
test   $0x1,%r8b
je     129c <multiply+0x19c>
movdqu (%rdi,%rax,4),%xmm2
movdqu 0x10(%rdi,%rax,4),%xmm3
movdqu (%r9,%rax,4),%xmm4
movdqu 0x10(%r9,%rax,4),%xmm5
pshufd $0xf5,%xmm4,%xmm6
pmuludq %xmm2,%xmm4
pshufd $0xe8,%xmm4,%xmm4
pshufd $0xf5,%xmm2,%xmm2
pmuludq %xmm6,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm4
paddd  %xmm4,%xmm0
pshufd $0xf5,%xmm5,%xmm2
pmuludq %xmm3,%xmm5
pshufd $0xe8,%xmm5,%xmm4
pshufd $0xf5,%xmm3,%xmm3
pmuludq %xmm2,%xmm3
pshufd $0xe8,%xmm3,%xmm2
punpckldq %xmm2,%xmm4
paddd  %xmm4,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%eax
cmp    %r10,%rsi
je     12d3 <multiply+0x1d3>
nopl   0x0(%rax,%rax,1)
mov    (%r9,%rsi,4),%ecx
imul   (%rdi,%rsi,4),%ecx
add    %ecx,%eax
add    $0x1,%rsi
cmp    %rsi,%r10
jne    12c0 <multiply+0x1c0>
ret
pxor   %xmm0,%xmm0
xor    %eax,%eax
pxor   %xmm1,%xmm1
test   $0x1,%r8b
jne    123c <multiply+0x13c>
jmp    129c <multiply+0x19c>

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

LLVM IR (-O2):
define i32 @multiply(i8* nocapture %0, i32 %1) {
%3 = bitcast i8* %0 to i32*
%4 = sext i32 %1 to i64
%5 = getelementptr inbounds i32, i32* %3, i64 %4
%6 = icmp sgt i32 %1, 0
br i1 %6, label %7, label %104
7: ; preds = %2
%8 = zext i32 %1 to i64
%9 = icmp ult i32 %1, 8
br i1 %9, label %90, label %10
10: ; preds = %7
%11 = and i64 %8, 4294967288
%12 = add nsw i64 %11, -8
%13 = lshr exact i64 %12, 3
%14 = add nuw nsw i64 %13, 1
%15 = and i64 %14, 1
%16 = icmp eq i64 %12, 0
br i1 %16, label %60, label %17
17: ; preds = %10
%18 = and i64 %14, 4611686018427387902
br label %19
19: ; preds = %19, %17
%20 = phi i64 [ 0, %17 ], [ %57, %19 ]
%21 = phi <4 x i32> [ zeroinitializer, %17 ], [ %55, %19 ]
%22 = phi <4 x i32> [ zeroinitializer, %17 ], [ %56, %19 ]
%23 = phi i64 [ 0, %17 ], [ %58, %19 ]
%24 = getelementptr inbounds i32, i32* %3, i64 %20
%25 = bitcast i32* %24 to <4 x i32>*
%26 = load <4 x i32>, <4 x i32>* %25
%27 = getelementptr inbounds i32, i32* %24, i64 4
%28 = bitcast i32* %27 to <4 x i32>*
%29 = load <4 x i32>, <4 x i32>* %28
%30 = getelementptr inbounds i32, i32* %5, i64 %20
%31 = bitcast i32* %30 to <4 x i32>*
%32 = load <4 x i32>, <4 x i32>* %31
%33 = getelementptr inbounds i32, i32* %30, i64 4
%34 = bitcast i32* %33 to <4 x i32>*
%35 = load <4 x i32>, <4 x i32>* %34
%36 = mul nsw <4 x i32> %32, %26
%37 = mul nsw <4 x i32> %35, %29
%38 = add <4 x i32> %36, %21
%39 = add <4 x i32> %37, %22
%40 = or i64 %20, 8
%41 = getelementptr inbounds i32, i32* %3, i64 %40
%42 = bitcast i32* %41 to <4 x i32>*
%43 = load <4 x i32>, <4 x i32>* %42
%44 = getelementptr inbounds i32, i32* %41, i64 4
%45 = bitcast i32* %44 to <4 x i32>*
%46 = load <4 x i32>, <4 x i32>* %45
%47 = getelementptr inbounds i32, i32* %5, i64 %40
%48 = bitcast i32* %47 to <4 x i32>*
%49 = load <4 x i32>, <4 x i32>* %48
%50 = getelementptr inbounds i32, i32* %47, i64 4
%51 = bitcast i32* %50 to <4 x i32>*
%52 = load <4 x i32>, <4 x i32>* %51
%53 = mul nsw <4 x i32> %49, %43
%54 = mul nsw <4 x i32> %52, %46
%55 = add <4 x i32> %53, %38
%56 = add <4 x i32> %54, %39
%57 = add nuw i64 %20, 16
%58 = add i64 %23, 2
%59 = icmp eq i64 %58, %18
br i1 %59, label %60, label %19
60: ; preds = %19, %10
%61 = phi <4 x i32> [ undef, %10 ], [ %55, %19 ]
%62 = phi <4 x i32> [ undef, %10 ], [ %56, %19 ]
%63 = phi i64 [ 0, %10 ], [ %57, %19 ]
%64 = phi <4 x i32> [ zeroinitializer, %10 ], [ %55, %19 ]
%65 = phi <4 x i32> [ zeroinitializer, %10 ], [ %56, %19 ]
%66 = icmp eq i64 %15, 0
br i1 %66, label %84, label %67
67: ; preds = %60
%68 = getelementptr inbounds i32, i32* %3, i64 %63
%69 = bitcast i32* %68 to <4 x i32>*
%70 = load <4 x i32>, <4 x i32>* %69
%71 = getelementptr inbounds i32, i32* %68, i64 4
%72 = bitcast i32* %71 to <4 x i32>*
%73 = load <4 x i32>, <4 x i32>* %72
%74 = getelementptr inbounds i32, i32* %5, i64 %63
%75 = bitcast i32* %74 to <4 x i32>*
%76 = load <4 x i32>, <4 x i32>* %75
%77 = getelementptr inbounds i32, i32* %74, i64 4
%78 = bitcast i32* %77 to <4 x i32>*
%79 = load <4 x i32>, <4 x i32>* %78
%80 = mul nsw <4 x i32> %76, %70
%81 = mul nsw <4 x i32> %79, %73
%82 = add <4 x i32> %80, %64
%83 = add <4 x i32> %81, %65
br label %84
84: ; preds = %60, %67
%85 = phi <4 x i32> [ %61, %60 ], [ %82, %67 ]
%86 = phi <4 x i32> [ %62, %60 ], [ %83, %67 ]
%87 = add <4 x i32> %86, %85
%88 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %87)
%89 = icmp eq i64 %11, %8
br i1 %89, label %104, label %90
90: ; preds = %7, %84
%91 = phi i64 [ 0, %7 ], [ %11, %84 ]
%92 = phi i32 [ 0, %7 ], [ %88, %84 ]
br label %93
93: ; preds = %90, %93
%94 = phi i64 [ %102, %93 ], [ %91, %90 ]
%95 = phi i32 [ %101, %93 ], [ %92, %90 ]
%96 = getelementptr inbounds i32, i32* %3, i64 %94
%97 = load i32, i32* %96
%98 = getelementptr inbounds i32, i32* %5, i64 %94
%99 = load i32, i32* %98
%100 = mul nsw i32 %99, %97
%101 = add nsw i32 %100, %95
%102 = add nuw nsw i64 %94, 1
%103 = icmp eq i64 %102, %8
br i1 %103, label %104, label %93
104: ; preds = %93, %84, %2
%105 = phi i32 [ 0, %2 ], [ %88, %84 ], [ %101, %93 ]
ret i32 %105
}