void ip_calculate_checksum(unsigned char header[]) {
  int result, temp = 0, count, index;
  int h[10];
  long sum = 0;
  header[10] = 0;
  header[11] = 0;
  for (count = 0, index = 0; count < 10; ++count, index += 2) {
    h[count] = header[index];
    h[count] = (h[count] << 8);
    h[count] |= header[index + 1];
  }
  for (count = 0; count < 10; ++count) {
    sum += h[count];
  }
  temp = (sum >> 16);
  sum &= 0xFFFF;
  result = sum;
  result += temp;
  result = ~result;
  header[10] = (result >> 8);
  header[11] = (result & 0x00FF);
}


x86 assembly (clang, -O0):
<ip_calculate_checksum>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
movl   $0x0,-0x10(%rbp)
movq   $0x0,-0x48(%rbp)
mov    -0x8(%rbp),%rax
movb   $0x0,0xa(%rax)
mov    -0x8(%rbp),%rax
movb   $0x0,0xb(%rax)
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
cmpl   $0xa,-0x14(%rbp)
jge    119a <ip_calculate_checksum+0x9a>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movzbl (%rax,%rcx,1),%ecx
movslq -0x14(%rbp),%rax
mov    %ecx,-0x40(%rbp,%rax,4)
movslq -0x14(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%ecx
shl    $0x8,%ecx
movslq -0x14(%rbp),%rax
mov    %ecx,-0x40(%rbp,%rax,4)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%ecx
movslq -0x14(%rbp),%rax
or     -0x40(%rbp,%rax,4),%ecx
mov    %ecx,-0x40(%rbp,%rax,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x18(%rbp)
jmp    1135 <ip_calculate_checksum+0x35>
movl   $0x0,-0x14(%rbp)
cmpl   $0xa,-0x14(%rbp)
jge    11ca <ip_calculate_checksum+0xca>
movslq -0x14(%rbp),%rax
movslq -0x40(%rbp,%rax,4),%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11a1 <ip_calculate_checksum+0xa1>
mov    -0x48(%rbp),%rax
sar    $0x10,%rax
mov    %eax,-0x10(%rbp)
mov    -0x48(%rbp),%rax
and    $0xffff,%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    %eax,-0xc(%rbp)
mov    -0x10(%rbp),%eax
add    -0xc(%rbp),%eax
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%eax
xor    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%eax
sar    $0x8,%eax
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %cl,0xa(%rax)
mov    -0xc(%rbp),%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %cl,0xb(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<ip_calculate_checksum>:
movzwl (%rdi),%eax
shl    $0x10,%eax
bswap  %eax
movzwl 0x2(%rdi),%ecx
shl    $0x10,%ecx
bswap  %ecx
add    %eax,%ecx
movzwl 0x4(%rdi),%eax
shl    $0x10,%eax
bswap  %eax
add    %ecx,%eax
movzwl 0x6(%rdi),%ecx
shl    $0x10,%ecx
bswap  %ecx
add    %eax,%ecx
movzwl 0x8(%rdi),%eax
shl    $0x10,%eax
bswap  %eax
add    %ecx,%eax
movzwl 0xc(%rdi),%ecx
shl    $0x10,%ecx
bswap  %ecx
add    %eax,%ecx
movzwl 0xe(%rdi),%eax
shl    $0x10,%eax
bswap  %eax
add    %ecx,%eax
movzwl 0x10(%rdi),%ecx
shl    $0x10,%ecx
bswap  %ecx
add    %eax,%ecx
movzwl 0x12(%rdi),%eax
shl    $0x10,%eax
bswap  %eax
add    %ecx,%eax
mov    %eax,%ecx
shr    $0x10,%ecx
add    %eax,%ecx
not    %ecx
rol    $0x8,%cx
mov    %cx,0xa(%rdi)
ret

LLVM IR (-O0):
define void @ip_calculate_checksum(i8* %0) {
%2 = alloca i8*
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca [10 x i32]
%8 = alloca i64
store i8* %0, i8** %2
store i32 0, i32* %4
store i64 0, i64* %8
%9 = load i8*, i8** %2
%10 = getelementptr inbounds i8, i8* %9, i64 10
store i8 0, i8* %10
%11 = load i8*, i8** %2
%12 = getelementptr inbounds i8, i8* %11, i64 11
store i8 0, i8* %12
store i32 0, i32* %5
store i32 0, i32* %6
br label %13
13: ; preds = %46, %1
%14 = load i32, i32* %5
%15 = icmp slt i32 %14, 10
br i1 %15, label %16, label %51
16: ; preds = %13
%17 = load i8*, i8** %2
%18 = load i32, i32* %6
%19 = sext i32 %18 to i64
%20 = getelementptr inbounds i8, i8* %17, i64 %19
%21 = load i8, i8* %20
%22 = zext i8 %21 to i32
%23 = load i32, i32* %5
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds [10 x i32], [10 x i32]* %7, i64 0, i64 %24
store i32 %22, i32* %25
%26 = load i32, i32* %5
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds [10 x i32], [10 x i32]* %7, i64 0, i64 %27
%29 = load i32, i32* %28
%30 = shl i32 %29, 8
%31 = load i32, i32* %5
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds [10 x i32], [10 x i32]* %7, i64 0, i64 %32
store i32 %30, i32* %33
%34 = load i8*, i8** %2
%35 = load i32, i32* %6
%36 = add nsw i32 %35, 1
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds i8, i8* %34, i64 %37
%39 = load i8, i8* %38
%40 = zext i8 %39 to i32
%41 = load i32, i32* %5
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds [10 x i32], [10 x i32]* %7, i64 0, i64 %42
%44 = load i32, i32* %43
%45 = or i32 %44, %40
store i32 %45, i32* %43
br label %46
46: ; preds = %16
%47 = load i32, i32* %5
%48 = add nsw i32 %47, 1
store i32 %48, i32* %5
%49 = load i32, i32* %6
%50 = add nsw i32 %49, 2
store i32 %50, i32* %6
br label %13
51: ; preds = %13
store i32 0, i32* %5
br label %52
52: ; preds = %63, %51
%53 = load i32, i32* %5
%54 = icmp slt i32 %53, 10
br i1 %54, label %55, label %66
55: ; preds = %52
%56 = load i32, i32* %5
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds [10 x i32], [10 x i32]* %7, i64 0, i64 %57
%59 = load i32, i32* %58
%60 = sext i32 %59 to i64
%61 = load i64, i64* %8
%62 = add nsw i64 %61, %60
store i64 %62, i64* %8
br label %63
63: ; preds = %55
%64 = load i32, i32* %5
%65 = add nsw i32 %64, 1
store i32 %65, i32* %5
br label %52
66: ; preds = %52
%67 = load i64, i64* %8
%68 = ashr i64 %67, 16
%69 = trunc i64 %68 to i32
store i32 %69, i32* %4
%70 = load i64, i64* %8
%71 = and i64 %70, 65535
store i64 %71, i64* %8
%72 = load i64, i64* %8
%73 = trunc i64 %72 to i32
store i32 %73, i32* %3
%74 = load i32, i32* %4
%75 = load i32, i32* %3
%76 = add nsw i32 %75, %74
store i32 %76, i32* %3
%77 = load i32, i32* %3
%78 = xor i32 %77, -1
store i32 %78, i32* %3
%79 = load i32, i32* %3
%80 = ashr i32 %79, 8
%81 = trunc i32 %80 to i8
%82 = load i8*, i8** %2
%83 = getelementptr inbounds i8, i8* %82, i64 10
store i8 %81, i8* %83
%84 = load i32, i32* %3
%85 = and i32 %84, 255
%86 = trunc i32 %85 to i8
%87 = load i8*, i8** %2
%88 = getelementptr inbounds i8, i8* %87, i64 11
store i8 %86, i8* %88
ret void
}

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