int sumarray3d(int a[1000][1000][1000]) {
  int i, j, k, sum = 0;
  for (i = 0; i < 1000; i++) {
    for (j = 0; j < 1000; j++) {
      for (k = 0; k < 1000; k++) {
        sum += a[i][j][k];
      }
    }
  }
  return sum;
}


x86 assembly (clang, -O0):
<sumarray3d>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0xc(%rbp)
cmpl   $0x3e8,-0xc(%rbp)
jge    11ac <sumarray3d+0xac>
movl   $0x0,-0x10(%rbp)
cmpl   $0x3e8,-0x10(%rbp)
jge    1199 <sumarray3d+0x99>
movl   $0x0,-0x14(%rbp)
cmpl   $0x3e8,-0x14(%rbp)
jge    1186 <sumarray3d+0x86>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
imul   $0x3d0900,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
imul   $0xfa0,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    113e <sumarray3d+0x3e>
jmp    118b <sumarray3d+0x8b>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    112a <sumarray3d+0x2a>
jmp    119e <sumarray3d+0x9e>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1116 <sumarray3d+0x16>
mov    -0x18(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<sumarray3d>:
xor    %ecx,%ecx
xor    %eax,%eax
jmp    1128 <sumarray3d+0x28>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rcx
add    $0x3d0900,%rdi
cmp    $0x3e8,%rcx
je     11cd <sumarray3d+0xcd>
mov    %rdi,%rdx
xor    %esi,%esi
jmp    115e <sumarray3d+0x5e>
nop
paddd  %xmm2,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%eax
add    $0x1,%rsi
add    $0xfa0,%rdx
cmp    $0x3e8,%rsi
je     1110 <sumarray3d+0x10>
movd   %eax,%xmm0
pxor   %xmm1,%xmm1
mov    $0x1c,%eax
nopl   0x0(%rax,%rax,1)
movdqu -0x70(%rdx,%rax,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x60(%rdx,%rax,4),%xmm0
paddd  %xmm1,%xmm0
cmp    $0x3fc,%rax
je     1130 <sumarray3d+0x30>
movdqu -0x50(%rdx,%rax,4),%xmm1
movdqu -0x40(%rdx,%rax,4),%xmm3
movdqu -0x30(%rdx,%rax,4),%xmm4
movdqu -0x20(%rdx,%rax,4),%xmm5
paddd  %xmm2,%xmm1
paddd  %xmm0,%xmm3
movdqu -0x10(%rdx,%rax,4),%xmm0
paddd  %xmm4,%xmm0
paddd  %xmm1,%xmm0
movdqu (%rdx,%rax,4),%xmm1
paddd  %xmm5,%xmm1
paddd  %xmm3,%xmm1
add    $0x20,%rax
jmp    1170 <sumarray3d+0x70>
ret

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

LLVM IR (-O2):
define i32 @sumarray3d([1000 x [1000 x i32]]* nocapture %0) {
br label %2
2: ; preds = %1, %56
%3 = phi i64 [ 0, %1 ], [ %57, %56 ]
%4 = phi i32 [ 0, %1 ], [ %53, %56 ]
br label %5
5: ; preds = %51, %2
%6 = phi i64 [ 0, %2 ], [ %54, %51 ]
%7 = phi i32 [ %4, %2 ], [ %53, %51 ]
%8 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %7, i64 0
br label %9
9: ; preds = %23, %5
%10 = phi i64 [ 0, %5 ], [ %50, %23 ]
%11 = phi <4 x i32> [ %8, %5 ], [ %48, %23 ]
%12 = phi <4 x i32> [ zeroinitializer, %5 ], [ %49, %23 ]
%13 = getelementptr inbounds [1000 x [1000 x i32]], [1000 x [1000 x i32]]* %0, i64 %3, i64 %6, i64 %10
%14 = bitcast i32* %13 to <4 x i32>*
%15 = load <4 x i32>, <4 x i32>* %14
%16 = getelementptr inbounds i32, i32* %13, i64 4
%17 = bitcast i32* %16 to <4 x i32>*
%18 = load <4 x i32>, <4 x i32>* %17
%19 = add <4 x i32> %15, %11
%20 = add <4 x i32> %18, %12
%21 = or i64 %10, 8
%22 = icmp eq i64 %21, 1000
br i1 %22, label %51, label %23
23: ; preds = %9
%24 = getelementptr inbounds [1000 x [1000 x i32]], [1000 x [1000 x i32]]* %0, i64 %3, i64 %6, i64 %21
%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 = add <4 x i32> %26, %19
%31 = add <4 x i32> %29, %20
%32 = or i64 %10, 16
%33 = getelementptr inbounds [1000 x [1000 x i32]], [1000 x [1000 x i32]]* %0, i64 %3, i64 %6, i64 %32
%34 = bitcast i32* %33 to <4 x i32>*
%35 = load <4 x i32>, <4 x i32>* %34
%36 = getelementptr inbounds i32, i32* %33, i64 4
%37 = bitcast i32* %36 to <4 x i32>*
%38 = load <4 x i32>, <4 x i32>* %37
%39 = add <4 x i32> %35, %30
%40 = add <4 x i32> %38, %31
%41 = or i64 %10, 24
%42 = getelementptr inbounds [1000 x [1000 x i32]], [1000 x [1000 x i32]]* %0, i64 %3, i64 %6, i64 %41
%43 = bitcast i32* %42 to <4 x i32>*
%44 = load <4 x i32>, <4 x i32>* %43
%45 = getelementptr inbounds i32, i32* %42, i64 4
%46 = bitcast i32* %45 to <4 x i32>*
%47 = load <4 x i32>, <4 x i32>* %46
%48 = add <4 x i32> %44, %39
%49 = add <4 x i32> %47, %40
%50 = add nuw nsw i64 %10, 32
br label %9
51: ; preds = %9
%52 = add <4 x i32> %20, %19
%53 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %52)
%54 = add nuw nsw i64 %6, 1
%55 = icmp eq i64 %54, 1000
br i1 %55, label %56, label %5
56: ; preds = %51
%57 = add nuw nsw i64 %3, 1
%58 = icmp eq i64 %57, 1000
br i1 %58, label %59, label %2
59: ; preds = %56
ret i32 %53
}