int sumofdigits(char *number) {
  int sum = 0, size = 0, i = 0;
  while (number[++size] != '\x0')
    ;
  for (i = 0; i < size; i++) {
    sum += (number[i] - '0');
  }
  return sum;
}


x86 assembly (clang, -O0):
<sumofdigits>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x10(%rbp)
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     113f <sumofdigits+0x3f>
jmp    111d <sumofdigits+0x1d>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1175 <sumofdigits+0x75>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x30,%eax
add    -0xc(%rbp),%eax
mov    %eax,-0xc(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1146 <sumofdigits+0x46>
mov    -0xc(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<sumofdigits>:
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmpb   $0x0,0x1(%rdi,%rdx,1)
lea    0x1(%rdx),%rdx
jne    1110 <sumofdigits+0x10>
mov    %edx,%ecx
cmp    $0x8,%rcx
jae    112c <sumofdigits+0x2c>
xor    %ecx,%ecx
xor    %eax,%eax
jmp    11ad <sumofdigits+0xad>
mov    %edx,%eax
mov    %edx,%r8d
and    $0x7,%r8d
sub    %r8,%rcx
sub    %r8,%rax
pxor   %xmm0,%xmm0
xor    %esi,%esi
movdqa 0xeb7(%rip),%xmm2
pxor   %xmm1,%xmm1
nopl   (%rax)
movd   (%rdi,%rsi,1),%xmm3
punpcklbw %xmm3,%xmm3
punpcklwd %xmm3,%xmm3
movd   0x4(%rdi,%rsi,1),%xmm4
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
psrad  $0x18,%xmm3
psrad  $0x18,%xmm4
paddd  %xmm2,%xmm0
paddd  %xmm3,%xmm0
paddd  %xmm2,%xmm1
paddd  %xmm4,%xmm1
add    $0x8,%rsi
cmp    %rsi,%rax
jne    1150 <sumofdigits+0x50>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%eax
test   %r8,%r8
je     11c2 <sumofdigits+0xc2>
mov    %edx,%edx
nop
movsbl (%rdi,%rcx,1),%esi
add    %esi,%eax
add    $0xffffffd0,%eax
add    $0x1,%rcx
cmp    %rcx,%rdx
jne    11b0 <sumofdigits+0xb0>
ret

LLVM IR (-O0):
define i32 @sumofdigits(i8* %0) {
%2 = alloca i8*
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
store i8* %0, i8** %2
store i32 0, i32* %3
store i32 0, i32* %4
store i32 0, i32* %5
br label %6
6: ; preds = %15, %1
%7 = load i8*, i8** %2
%8 = load i32, i32* %4
%9 = add nsw i32 %8, 1
store i32 %9, i32* %4
%10 = sext i32 %9 to i64
%11 = getelementptr inbounds i8, i8* %7, i64 %10
%12 = load i8, i8* %11
%13 = sext i8 %12 to i32
%14 = icmp ne i32 %13, 0
br i1 %14, label %15, label %16
15: ; preds = %6
br label %6
16: ; preds = %6
store i32 0, i32* %5
br label %17
17: ; preds = %31, %16
%18 = load i32, i32* %5
%19 = load i32, i32* %4
%20 = icmp slt i32 %18, %19
br i1 %20, label %21, label %34
21: ; preds = %17
%22 = load i8*, i8** %2
%23 = load i32, i32* %5
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds i8, i8* %22, i64 %24
%26 = load i8, i8* %25
%27 = sext i8 %26 to i32
%28 = sub nsw i32 %27, 48
%29 = load i32, i32* %3
%30 = add nsw i32 %29, %28
store i32 %30, i32* %3
br label %31
31: ; preds = %21
%32 = load i32, i32* %5
%33 = add nsw i32 %32, 1
store i32 %33, i32* %5
br label %17
34: ; preds = %17
%35 = load i32, i32* %3
ret i32 %35
}

LLVM IR (-O2):
define i32 @sumofdigits(i8* nocapture %0) {
br label %2
2: ; preds = %2, %1
%3 = phi i64 [ %4, %2 ], [ 0, %1 ]
%4 = add nuw nsw i64 %3, 1
%5 = getelementptr inbounds i8, i8* %0, i64 %4
%6 = load i8, i8* %5
%7 = icmp eq i8 %6, 0
br i1 %7, label %8, label %2
8: ; preds = %2
%9 = add nuw i64 %3, 1
%10 = and i64 %9, 4294967295
%11 = icmp ult i64 %10, 8
br i1 %11, label %37, label %12
12: ; preds = %8
%13 = and i64 %9, 7
%14 = sub nsw i64 %10, %13
br label %15
15: ; preds = %15, %12
%16 = phi i64 [ 0, %12 ], [ %31, %15 ]
%17 = phi <4 x i32> [ zeroinitializer, %12 ], [ %29, %15 ]
%18 = phi <4 x i32> [ zeroinitializer, %12 ], [ %30, %15 ]
%19 = getelementptr inbounds i8, i8* %0, i64 %16
%20 = bitcast i8* %19 to <4 x i8>*
%21 = load <4 x i8>, <4 x i8>* %20
%22 = getelementptr inbounds i8, i8* %19, i64 4
%23 = bitcast i8* %22 to <4 x i8>*
%24 = load <4 x i8>, <4 x i8>* %23
%25 = sext <4 x i8> %21 to <4 x i32>
%26 = sext <4 x i8> %24 to <4 x i32>
%27 = add <4 x i32> %17, <i32 -48, i32 -48, i32 -48, i32 -48>
%28 = add <4 x i32> %18, <i32 -48, i32 -48, i32 -48, i32 -48>
%29 = add <4 x i32> %27, %25
%30 = add <4 x i32> %28, %26
%31 = add nuw i64 %16, 8
%32 = icmp eq i64 %31, %14
br i1 %32, label %33, label %15
33: ; preds = %15
%34 = add <4 x i32> %30, %29
%35 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %34)
%36 = icmp eq i64 %13, 0
br i1 %36, label %50, label %37
37: ; preds = %8, %33
%38 = phi i64 [ 0, %8 ], [ %14, %33 ]
%39 = phi i32 [ 0, %8 ], [ %35, %33 ]
br label %40
40: ; preds = %37, %40
%41 = phi i64 [ %48, %40 ], [ %38, %37 ]
%42 = phi i32 [ %47, %40 ], [ %39, %37 ]
%43 = getelementptr inbounds i8, i8* %0, i64 %41
%44 = load i8, i8* %43
%45 = sext i8 %44 to i32
%46 = add i32 %42, -48
%47 = add i32 %46, %45
%48 = add nuw nsw i64 %41, 1
%49 = icmp eq i64 %48, %10
br i1 %49, label %50, label %40
50: ; preds = %40, %33
%51 = phi i32 [ %35, %33 ], [ %47, %40 ]
ret i32 %51
}