int term(int *p1, int *p2, int t) {
  int sum = 0;
  for (int i = 0; i <= t; i++)
    sum += p1[i] * p2[t - i];
  return sum;
}


x86 assembly (clang, -O0):
<term>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1159 <term+0x59>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
mov    -0x14(%rbp),%edx
sub    -0x1c(%rbp),%edx
movslq %edx,%rdx
imul   (%rcx,%rdx,4),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    111d <term+0x1d>
mov    -0x18(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<term>:
push   %rbx
test   %edx,%edx
js     111a <term+0x1a>
mov    %edx,%r8d
lea    0x1(%rdx),%r10d
cmp    $0x7,%edx
jae    111e <term+0x1e>
xor    %edx,%edx
xor    %eax,%eax
jmp    12e8 <term+0x1e8>
xor    %eax,%eax
pop    %rbx
ret
mov    %r10d,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rax
mov    %rax,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rax,%rax
je     1307 <term+0x207>
mov    %r9,%r11
and    $0xfffffffffffffffe,%r11
lea    0x30(%rdi),%rcx
lea    (%rsi,%r8,4),%rbx
add    $0xfffffffffffffff4,%rbx
pxor   %xmm0,%xmm0
xor    %eax,%eax
pxor   %xmm1,%xmm1
nopl   0x0(%rax)
movdqu -0x30(%rbx,%rax,4),%xmm8
movdqu -0x20(%rbx,%rax,4),%xmm10
movdqu -0x10(%rbx,%rax,4),%xmm6
movdqu (%rbx,%rax,4),%xmm3
pshufd $0x1b,%xmm3,%xmm7
pshufd $0x1b,%xmm6,%xmm2
pshufd $0x4e,%xmm3,%xmm12
movdqu -0x30(%rcx),%xmm4
movdqu -0x20(%rcx),%xmm5
movdqu -0x10(%rcx),%xmm11
movdqu (%rcx),%xmm9
pshufd $0xf5,%xmm4,%xmm3
pmuludq %xmm12,%xmm3
pshufd $0xe8,%xmm3,%xmm3
pmuludq %xmm4,%xmm7
pshufd $0xe8,%xmm7,%xmm4
punpckldq %xmm3,%xmm4
paddd  %xmm0,%xmm4
pshufd $0x4e,%xmm6,%xmm0
pshufd $0xf5,%xmm5,%xmm3
pmuludq %xmm0,%xmm3
pshufd $0xe8,%xmm3,%xmm0
pmuludq %xmm5,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm0,%xmm2
paddd  %xmm1,%xmm2
pshufd $0x1b,%xmm10,%xmm0
pshufd $0x1b,%xmm8,%xmm1
pshufd $0x4e,%xmm10,%xmm3
pshufd $0xf5,%xmm11,%xmm5
pmuludq %xmm3,%xmm5
pshufd $0xe8,%xmm5,%xmm3
pmuludq %xmm11,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm3,%xmm0
paddd  %xmm4,%xmm0
pshufd $0x4e,%xmm8,%xmm3
pshufd $0xf5,%xmm9,%xmm4
pmuludq %xmm3,%xmm4
pshufd $0xe8,%xmm4,%xmm3
pmuludq %xmm9,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm3,%xmm1
paddd  %xmm2,%xmm1
add    $0x40,%rcx
add    $0xfffffffffffffff0,%rax
add    $0xfffffffffffffffe,%r11
jne    1160 <term+0x60>
neg    %rax
test   $0x1,%r9b
je     12c9 <term+0x1c9>
movdqu (%rdi,%rax,4),%xmm2
movdqu 0x10(%rdi,%rax,4),%xmm8
mov    %r8,%rcx
sub    %rax,%rcx
movdqu -0x1c(%rsi,%rcx,4),%xmm4
movdqu -0xc(%rsi,%rcx,4),%xmm5
pshufd $0x1b,%xmm5,%xmm6
pshufd $0x1b,%xmm4,%xmm7
pshufd $0xf5,%xmm2,%xmm3
pshufd $0x4e,%xmm5,%xmm5
pmuludq %xmm3,%xmm5
pshufd $0xe8,%xmm5,%xmm3
pmuludq %xmm2,%xmm6
pshufd $0xe8,%xmm6,%xmm2
punpckldq %xmm3,%xmm2
paddd  %xmm2,%xmm0
pshufd $0xf5,%xmm8,%xmm2
pshufd $0x4e,%xmm4,%xmm3
pmuludq %xmm2,%xmm3
pshufd $0xe8,%xmm3,%xmm2
pmuludq %xmm8,%xmm7
pshufd $0xe8,%xmm7,%xmm3
punpckldq %xmm2,%xmm3
paddd  %xmm3,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%eax
cmp    %r10,%rdx
je     1305 <term+0x205>
sub    %rdx,%r8
lea    (%rsi,%r8,4),%rcx
nop
mov    (%rcx),%esi
imul   (%rdi,%rdx,4),%esi
add    %esi,%eax
add    $0x1,%rdx
add    $0xfffffffffffffffc,%rcx
cmp    %rdx,%r10
jne    12f0 <term+0x1f0>
pop    %rbx
ret
pxor   %xmm0,%xmm0
xor    %eax,%eax
pxor   %xmm1,%xmm1
test   $0x1,%r9b
jne    1257 <term+0x157>
jmp    12c9 <term+0x1c9>

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

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