int dumb_compare(char *s1, char *s2) {
  int i, j, k, retval;
  retval = (s1[0] - s2[0]);
  retval += (s1[1] - s2[1]);
  retval += (s1[2] - s2[2]);
  retval += (s1[3] - s2[3]);
  retval += (s1[4] - s2[4]);
  retval += (s1[5] - s2[5]);
  retval += (s1[6] - s2[6]);
  retval += (s1[7] - s2[7]);
  retval += (s1[8] - s2[8]);
  retval += (s1[9] - s2[9]);
  retval += (s1[10] - s2[10]);
  retval += (s1[11] - s2[11]);
  retval += (s1[12] - s2[12]);
  retval += (s1[13] - s2[13]);
  retval += (s1[14] - s2[14]);
  retval += (s1[15] - s2[15]);
  return retval;
}


x86 assembly (clang, -O0):
<dumb_compare>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
mov    -0x10(%rbp),%rcx
movsbl (%rcx),%ecx
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsbl 0x1(%rax),%eax
mov    -0x10(%rbp),%rcx
movsbl 0x1(%rcx),%ecx
sub    %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsbl 0x2(%rax),%eax
mov    -0x10(%rbp),%rcx
movsbl 0x2(%rcx),%ecx
sub    %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsbl 0x3(%rax),%eax
mov    -0x10(%rbp),%rcx
movsbl 0x3(%rcx),%ecx
sub    %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsbl 0x4(%rax),%eax
mov    -0x10(%rbp),%rcx
movsbl 0x4(%rcx),%ecx
sub    %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsbl 0x5(%rax),%eax
mov    -0x10(%rbp),%rcx
movsbl 0x5(%rcx),%ecx
sub    %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsbl 0x6(%rax),%eax
mov    -0x10(%rbp),%rcx
movsbl 0x6(%rcx),%ecx
sub    %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsbl 0x7(%rax),%eax
mov    -0x10(%rbp),%rcx
movsbl 0x7(%rcx),%ecx
sub    %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsbl 0x8(%rax),%eax
mov    -0x10(%rbp),%rcx
movsbl 0x8(%rcx),%ecx
sub    %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsbl 0x9(%rax),%eax
mov    -0x10(%rbp),%rcx
movsbl 0x9(%rcx),%ecx
sub    %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsbl 0xa(%rax),%eax
mov    -0x10(%rbp),%rcx
movsbl 0xa(%rcx),%ecx
sub    %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsbl 0xb(%rax),%eax
mov    -0x10(%rbp),%rcx
movsbl 0xb(%rcx),%ecx
sub    %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsbl 0xc(%rax),%eax
mov    -0x10(%rbp),%rcx
movsbl 0xc(%rcx),%ecx
sub    %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsbl 0xd(%rax),%eax
mov    -0x10(%rbp),%rcx
movsbl 0xd(%rcx),%ecx
sub    %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsbl 0xe(%rax),%eax
mov    -0x10(%rbp),%rcx
movsbl 0xe(%rcx),%ecx
sub    %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsbl 0xf(%rax),%eax
mov    -0x10(%rbp),%rcx
movsbl 0xf(%rcx),%ecx
sub    %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<dumb_compare>:
movdqu (%rdi),%xmm0
punpcklbw %xmm0,%xmm1
punpckhwd %xmm1,%xmm2
psrad  $0x18,%xmm2
punpckhbw %xmm0,%xmm3
punpckhwd %xmm3,%xmm0
psrad  $0x18,%xmm0
punpcklwd %xmm1,%xmm4
psrad  $0x18,%xmm4
punpcklwd %xmm3,%xmm1
psrad  $0x18,%xmm1
movdqu (%rsi),%xmm3
punpcklbw %xmm3,%xmm5
punpckhwd %xmm5,%xmm6
psrad  $0x18,%xmm6
psubd  %xmm6,%xmm2
punpckhbw %xmm3,%xmm3
punpckhwd %xmm3,%xmm6
psrad  $0x18,%xmm6
psubd  %xmm6,%xmm0
paddd  %xmm2,%xmm0
punpcklwd %xmm5,%xmm2
psrad  $0x18,%xmm2
psubd  %xmm2,%xmm4
punpcklwd %xmm3,%xmm2
psrad  $0x18,%xmm2
psubd  %xmm2,%xmm1
paddd  %xmm4,%xmm1
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%eax
ret

LLVM IR (-O0):
define i32 @dumb_compare(i8* %0, i8* %1) {
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
store i8* %0, i8** %3
store i8* %1, i8** %4
%9 = load i8*, i8** %3
%10 = getelementptr inbounds i8, i8* %9, i64 0
%11 = load i8, i8* %10
%12 = sext i8 %11 to i32
%13 = load i8*, i8** %4
%14 = getelementptr inbounds i8, i8* %13, i64 0
%15 = load i8, i8* %14
%16 = sext i8 %15 to i32
%17 = sub nsw i32 %12, %16
store i32 %17, i32* %8
%18 = load i8*, i8** %3
%19 = getelementptr inbounds i8, i8* %18, i64 1
%20 = load i8, i8* %19
%21 = sext i8 %20 to i32
%22 = load i8*, i8** %4
%23 = getelementptr inbounds i8, i8* %22, i64 1
%24 = load i8, i8* %23
%25 = sext i8 %24 to i32
%26 = sub nsw i32 %21, %25
%27 = load i32, i32* %8
%28 = add nsw i32 %27, %26
store i32 %28, i32* %8
%29 = load i8*, i8** %3
%30 = getelementptr inbounds i8, i8* %29, i64 2
%31 = load i8, i8* %30
%32 = sext i8 %31 to i32
%33 = load i8*, i8** %4
%34 = getelementptr inbounds i8, i8* %33, i64 2
%35 = load i8, i8* %34
%36 = sext i8 %35 to i32
%37 = sub nsw i32 %32, %36
%38 = load i32, i32* %8
%39 = add nsw i32 %38, %37
store i32 %39, i32* %8
%40 = load i8*, i8** %3
%41 = getelementptr inbounds i8, i8* %40, i64 3
%42 = load i8, i8* %41
%43 = sext i8 %42 to i32
%44 = load i8*, i8** %4
%45 = getelementptr inbounds i8, i8* %44, i64 3
%46 = load i8, i8* %45
%47 = sext i8 %46 to i32
%48 = sub nsw i32 %43, %47
%49 = load i32, i32* %8
%50 = add nsw i32 %49, %48
store i32 %50, i32* %8
%51 = load i8*, i8** %3
%52 = getelementptr inbounds i8, i8* %51, i64 4
%53 = load i8, i8* %52
%54 = sext i8 %53 to i32
%55 = load i8*, i8** %4
%56 = getelementptr inbounds i8, i8* %55, i64 4
%57 = load i8, i8* %56
%58 = sext i8 %57 to i32
%59 = sub nsw i32 %54, %58
%60 = load i32, i32* %8
%61 = add nsw i32 %60, %59
store i32 %61, i32* %8
%62 = load i8*, i8** %3
%63 = getelementptr inbounds i8, i8* %62, i64 5
%64 = load i8, i8* %63
%65 = sext i8 %64 to i32
%66 = load i8*, i8** %4
%67 = getelementptr inbounds i8, i8* %66, i64 5
%68 = load i8, i8* %67
%69 = sext i8 %68 to i32
%70 = sub nsw i32 %65, %69
%71 = load i32, i32* %8
%72 = add nsw i32 %71, %70
store i32 %72, i32* %8
%73 = load i8*, i8** %3
%74 = getelementptr inbounds i8, i8* %73, i64 6
%75 = load i8, i8* %74
%76 = sext i8 %75 to i32
%77 = load i8*, i8** %4
%78 = getelementptr inbounds i8, i8* %77, i64 6
%79 = load i8, i8* %78
%80 = sext i8 %79 to i32
%81 = sub nsw i32 %76, %80
%82 = load i32, i32* %8
%83 = add nsw i32 %82, %81
store i32 %83, i32* %8
%84 = load i8*, i8** %3
%85 = getelementptr inbounds i8, i8* %84, i64 7
%86 = load i8, i8* %85
%87 = sext i8 %86 to i32
%88 = load i8*, i8** %4
%89 = getelementptr inbounds i8, i8* %88, i64 7
%90 = load i8, i8* %89
%91 = sext i8 %90 to i32
%92 = sub nsw i32 %87, %91
%93 = load i32, i32* %8
%94 = add nsw i32 %93, %92
store i32 %94, i32* %8
%95 = load i8*, i8** %3
%96 = getelementptr inbounds i8, i8* %95, i64 8
%97 = load i8, i8* %96
%98 = sext i8 %97 to i32
%99 = load i8*, i8** %4
%100 = getelementptr inbounds i8, i8* %99, i64 8
%101 = load i8, i8* %100
%102 = sext i8 %101 to i32
%103 = sub nsw i32 %98, %102
%104 = load i32, i32* %8
%105 = add nsw i32 %104, %103
store i32 %105, i32* %8
%106 = load i8*, i8** %3
%107 = getelementptr inbounds i8, i8* %106, i64 9
%108 = load i8, i8* %107
%109 = sext i8 %108 to i32
%110 = load i8*, i8** %4
%111 = getelementptr inbounds i8, i8* %110, i64 9
%112 = load i8, i8* %111
%113 = sext i8 %112 to i32
%114 = sub nsw i32 %109, %113
%115 = load i32, i32* %8
%116 = add nsw i32 %115, %114
store i32 %116, i32* %8
%117 = load i8*, i8** %3
%118 = getelementptr inbounds i8, i8* %117, i64 10
%119 = load i8, i8* %118
%120 = sext i8 %119 to i32
%121 = load i8*, i8** %4
%122 = getelementptr inbounds i8, i8* %121, i64 10
%123 = load i8, i8* %122
%124 = sext i8 %123 to i32
%125 = sub nsw i32 %120, %124
%126 = load i32, i32* %8
%127 = add nsw i32 %126, %125
store i32 %127, i32* %8
%128 = load i8*, i8** %3
%129 = getelementptr inbounds i8, i8* %128, i64 11
%130 = load i8, i8* %129
%131 = sext i8 %130 to i32
%132 = load i8*, i8** %4
%133 = getelementptr inbounds i8, i8* %132, i64 11
%134 = load i8, i8* %133
%135 = sext i8 %134 to i32
%136 = sub nsw i32 %131, %135
%137 = load i32, i32* %8
%138 = add nsw i32 %137, %136
store i32 %138, i32* %8
%139 = load i8*, i8** %3
%140 = getelementptr inbounds i8, i8* %139, i64 12
%141 = load i8, i8* %140
%142 = sext i8 %141 to i32
%143 = load i8*, i8** %4
%144 = getelementptr inbounds i8, i8* %143, i64 12
%145 = load i8, i8* %144
%146 = sext i8 %145 to i32
%147 = sub nsw i32 %142, %146
%148 = load i32, i32* %8
%149 = add nsw i32 %148, %147
store i32 %149, i32* %8
%150 = load i8*, i8** %3
%151 = getelementptr inbounds i8, i8* %150, i64 13
%152 = load i8, i8* %151
%153 = sext i8 %152 to i32
%154 = load i8*, i8** %4
%155 = getelementptr inbounds i8, i8* %154, i64 13
%156 = load i8, i8* %155
%157 = sext i8 %156 to i32
%158 = sub nsw i32 %153, %157
%159 = load i32, i32* %8
%160 = add nsw i32 %159, %158
store i32 %160, i32* %8
%161 = load i8*, i8** %3
%162 = getelementptr inbounds i8, i8* %161, i64 14
%163 = load i8, i8* %162
%164 = sext i8 %163 to i32
%165 = load i8*, i8** %4
%166 = getelementptr inbounds i8, i8* %165, i64 14
%167 = load i8, i8* %166
%168 = sext i8 %167 to i32
%169 = sub nsw i32 %164, %168
%170 = load i32, i32* %8
%171 = add nsw i32 %170, %169
store i32 %171, i32* %8
%172 = load i8*, i8** %3
%173 = getelementptr inbounds i8, i8* %172, i64 15
%174 = load i8, i8* %173
%175 = sext i8 %174 to i32
%176 = load i8*, i8** %4
%177 = getelementptr inbounds i8, i8* %176, i64 15
%178 = load i8, i8* %177
%179 = sext i8 %178 to i32
%180 = sub nsw i32 %175, %179
%181 = load i32, i32* %8
%182 = add nsw i32 %181, %180
store i32 %182, i32* %8
%183 = load i32, i32* %8
ret i32 %183
}

LLVM IR (-O2):
define i32 @dumb_compare(i8* nocapture %0, i8* nocapture %1) {
%3 = bitcast i8* %0 to <16 x i8>*
%4 = load <16 x i8>, <16 x i8>* %3
%5 = sext <16 x i8> %4 to <16 x i32>
%6 = bitcast i8* %1 to <16 x i8>*
%7 = load <16 x i8>, <16 x i8>* %6
%8 = sext <16 x i8> %7 to <16 x i32>
%9 = sub nsw <16 x i32> %5, %8
%10 = call i32 @llvm.vector.reduce.add.v16i32(<16 x i32> %9)
ret i32 %10
}