#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
struct iovec {
  scalar_t__ iov_len;
};

/* Variables and functions */
size_t iovlen(const struct iovec *iov, size_t n) {
  size_t len = 0;
  while (n) {
    len += iov[--n].iov_len;
  }
  return len;
}


x86 assembly (clang, -O0):
<iovlen>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movq   $0x0,-0x18(%rbp)
cmpq   $0x0,-0x10(%rbp)
je     1144 <iovlen+0x44>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    %rcx,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x10(%rbp)
mov    -0x8(%rax,%rcx,8),%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    1114 <iovlen+0x14>
mov    -0x18(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<iovlen>:
test   %rsi,%rsi
je     1112 <iovlen+0x12>
cmp    $0x4,%rsi
jae    1115 <iovlen+0x15>
xor    %eax,%eax
jmp    11f0 <iovlen+0xf0>
xor    %eax,%eax
ret
mov    %rsi,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rax
mov    %rax,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rax,%rax
je     11ff <iovlen+0xff>
mov    %r9,%rax
and    $0xfffffffffffffffe,%rax
lea    (%rdi,%rsi,8),%rcx
add    $0xfffffffffffffff0,%rcx
pxor   %xmm0,%xmm0
mov    $0xfffffffffffffffe,%rdx
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu -0x20(%rcx,%rdx,8),%xmm2
movdqu -0x10(%rcx,%rdx,8),%xmm3
movdqu (%rcx,%rdx,8),%xmm4
movdqu 0x10(%rcx,%rdx,8),%xmm5
pshufd $0x4e,%xmm5,%xmm5
paddq  %xmm0,%xmm5
pshufd $0x4e,%xmm4,%xmm4
paddq  %xmm1,%xmm4
pshufd $0x4e,%xmm3,%xmm0
paddq  %xmm5,%xmm0
pshufd $0x4e,%xmm2,%xmm1
paddq  %xmm4,%xmm1
add    $0xfffffffffffffff8,%rdx
add    $0xfffffffffffffffe,%rax
jne    1160 <iovlen+0x60>
add    $0x1,%rdx
test   $0x1,%r9b
je     11d0 <iovlen+0xd0>
add    %rsi,%rdx
movdqu -0x18(%rdi,%rdx,8),%xmm2
movdqu -0x8(%rdi,%rdx,8),%xmm3
pshufd $0x4e,%xmm3,%xmm3
paddq  %xmm3,%xmm0
pshufd $0x4e,%xmm2,%xmm2
paddq  %xmm2,%xmm1
paddq  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddq  %xmm0,%xmm1
movq   %xmm1,%rax
cmp    %rsi,%r8
je     11fe <iovlen+0xfe>
and    $0x3,%esi
nopw   0x0(%rax,%rax,1)
add    -0x8(%rdi,%rsi,8),%rax
add    $0xffffffffffffffff,%rsi
test   %rsi,%rsi
jne    11f0 <iovlen+0xf0>
ret
pxor   %xmm0,%xmm0
mov    $0xffffffffffffffff,%rdx
pxor   %xmm1,%xmm1
test   $0x1,%r9b
jne    11af <iovlen+0xaf>
jmp    11d0 <iovlen+0xd0>

LLVM IR (-O0):
%struct.iovec = type { i64 }
define i64 @iovlen(%struct.iovec* %0, i64 %1) {
%3 = alloca %struct.iovec*
%4 = alloca i64
%5 = alloca i64
store %struct.iovec* %0, %struct.iovec** %3
store i64 %1, i64* %4
store i64 0, i64* %5
br label %6
6: ; preds = %9, %2
%7 = load i64, i64* %4
%8 = icmp ne i64 %7, 0
br i1 %8, label %9, label %18
9: ; preds = %6
%10 = load %struct.iovec*, %struct.iovec** %3
%11 = load i64, i64* %4
%12 = add i64 %11, -1
store i64 %12, i64* %4
%13 = getelementptr inbounds %struct.iovec, %struct.iovec* %10, i64 %12
%14 = getelementptr inbounds %struct.iovec, %struct.iovec* %13, i32 0, i32 0
%15 = load i64, i64* %14
%16 = load i64, i64* %5
%17 = add i64 %16, %15
store i64 %17, i64* %5
br label %6
18: ; preds = %6
%19 = load i64, i64* %5
ret i64 %19
}

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