void quadradoVETOR(int vector[], int n) {
  for (n--; n >= 0; --n)
    vector[n] = vector[n] * vector[n];
}


x86 assembly (clang, -O0):
<quadradoVETOR>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
cmpl   $0x0,-0xc(%rbp)
jl     114e <quadradoVETOR+0x4e>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
jmp    1114 <quadradoVETOR+0x14>
pop    %rbp
ret

x86 assembly (clang, -O2):
<quadradoVETOR>:
test   %esi,%esi
jle    1126 <quadradoVETOR+0x26>
mov    %esi,%eax
cmp    $0x8,%esi
jae    1127 <quadradoVETOR+0x27>
add    $0x1,%rax
nop
lea    -0x2(%rax),%ecx
mov    (%rdi,%rcx,4),%edx
imul   %edx,%edx
mov    %edx,(%rdi,%rcx,4)
add    $0xffffffffffffffff,%rax
cmp    $0x1,%rax
ja     1110 <quadradoVETOR+0x10>
ret
lea    -0x1(%rax),%r11
add    $0xffffffff,%esi
cmp    %r11d,%esi
jb     110b <quadradoVETOR+0xb>
mov    %r11,%rdx
shr    $0x20,%rdx
jne    110b <quadradoVETOR+0xb>
mov    %eax,%r8d
and    $0xfffffff8,%r8d
lea    -0x8(%r8),%rdx
mov    %rdx,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rdx,%rdx
je     1296 <quadradoVETOR+0x196>
mov    %r9,%rsi
and    $0xfffffffffffffffe,%rsi
mov    $0xfffffff7,%edx
add    %rax,%rdx
mov    $0x1,%r10d
mov    %r11d,%ecx
movdqu -0x1c(%rdi,%rcx,4),%xmm0
movdqu -0xc(%rdi,%rcx,4),%xmm1
pshufd $0xf5,%xmm1,%xmm2
pmuludq %xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pmuludq %xmm2,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm1
pshufd $0xf5,%xmm0,%xmm2
pmuludq %xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pmuludq %xmm2,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm0
movdqu %xmm1,-0xc(%rdi,%rcx,4)
movdqu %xmm0,-0x1c(%rdi,%rcx,4)
mov    %edx,%ecx
movdqu -0x1c(%rdi,%rcx,4),%xmm0
movdqu -0xc(%rdi,%rcx,4),%xmm1
pshufd $0xf5,%xmm1,%xmm2
pmuludq %xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pmuludq %xmm2,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm1
pshufd $0xf5,%xmm0,%xmm2
pmuludq %xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pmuludq %xmm2,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm0
movdqu %xmm1,-0xc(%rdi,%rcx,4)
movdqu %xmm0,-0x1c(%rdi,%rcx,4)
add    $0x10,%r10
add    $0xfffffffffffffff0,%rdx
add    $0xfffffffffffffff0,%r11
add    $0xfffffffffffffffe,%rsi
jne    1170 <quadradoVETOR+0x70>
neg    %r10
test   $0x1,%r9b
je     1285 <quadradoVETOR+0x185>
add    %eax,%r10d
movdqu -0x1c(%rdi,%r10,4),%xmm0
movdqu -0xc(%rdi,%r10,4),%xmm1
pshufd $0xf5,%xmm1,%xmm2
pmuludq %xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pmuludq %xmm2,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm1
pshufd $0xf5,%xmm0,%xmm2
pmuludq %xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pmuludq %xmm2,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm0
movdqu %xmm1,-0xc(%rdi,%r10,4)
movdqu %xmm0,-0x1c(%rdi,%r10,4)
cmp    %rax,%r8
je     1126 <quadradoVETOR+0x26>
and    $0x7,%eax
jmp    110b <quadradoVETOR+0xb>
mov    $0xffffffffffffffff,%r10
test   $0x1,%r9b
jne    1230 <quadradoVETOR+0x130>
jmp    1285 <quadradoVETOR+0x185>

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

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