int get_specific_char(char c, char *input, int total_size) {
  int count = 0;
  int size = total_size;
  while (size) {
    if (*input == c)
      count++;
    *input++;
    size--;
  }
  return count;
}


x86 assembly (clang, -O0):
<get_specific_char>:
push   %rbp
mov    %rsp,%rbp
mov    %dil,%al
mov    %al,-0x1(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
je     115e <get_specific_char+0x5e>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
movsbl -0x1(%rbp),%ecx
cmp    %ecx,%eax
jne    1144 <get_specific_char+0x44>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    111e <get_specific_char+0x1e>
mov    -0x18(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_specific_char>:
test   %edx,%edx
je     1265 <get_specific_char+0x165>
lea    -0x1(%rdx),%r9d
xor    %eax,%eax
cmp    $0x7,%r9d
jb     1247 <get_specific_char+0x147>
add    $0x1,%r9
mov    %r9,%r8
and    $0xfffffffffffffff8,%r8
movzbl %dil,%eax
movd   %eax,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
lea    -0x8(%r8),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
test   %rax,%rax
je     1268 <get_specific_char+0x168>
mov    %r10,%rax
and    $0xfffffffffffffffe,%rax
pxor   %xmm1,%xmm1
xor    %ecx,%ecx
movdqa 0xe9f(%rip),%xmm3
pxor   %xmm2,%xmm2
cs nopw 0x0(%rax,%rax,1)
nop
movd   (%rsi,%rcx,1),%xmm5
movd   0x4(%rsi,%rcx,1),%xmm4
pcmpeqb %xmm0,%xmm5
punpcklbw %xmm5,%xmm5
punpcklwd %xmm5,%xmm5
pand   %xmm3,%xmm5
paddd  %xmm1,%xmm5
pcmpeqb %xmm0,%xmm4
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
pand   %xmm3,%xmm4
paddd  %xmm2,%xmm4
movd   0x8(%rsi,%rcx,1),%xmm1
movd   0xc(%rsi,%rcx,1),%xmm2
pcmpeqb %xmm0,%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
pand   %xmm3,%xmm1
paddd  %xmm5,%xmm1
pcmpeqb %xmm0,%xmm2
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
pand   %xmm3,%xmm2
paddd  %xmm4,%xmm2
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rax
jne    1170 <get_specific_char+0x70>
test   $0x1,%r10b
je     1222 <get_specific_char+0x122>
movd   (%rsi,%rcx,1),%xmm3
movd   0x4(%rsi,%rcx,1),%xmm4
pcmpeqb %xmm0,%xmm3
punpcklbw %xmm3,%xmm3
punpcklwd %xmm3,%xmm3
movdqa 0xdfa(%rip),%xmm5
pand   %xmm5,%xmm3
paddd  %xmm3,%xmm1
pcmpeqb %xmm0,%xmm4
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
pand   %xmm5,%xmm4
paddd  %xmm4,%xmm2
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%eax
cmp    %r8,%r9
je     1264 <get_specific_char+0x164>
sub    %r8d,%edx
add    %r8,%rsi
mov    %edx,%r8d
xor    %edx,%edx
nopl   0x0(%rax)
xor    %ecx,%ecx
cmp    %dil,(%rsi,%rdx,1)
sete   %cl
add    %ecx,%eax
add    $0x1,%rdx
cmp    %edx,%r8d
jne    1250 <get_specific_char+0x150>
ret
xor    %eax,%eax
ret
pxor   %xmm1,%xmm1
xor    %ecx,%ecx
pxor   %xmm2,%xmm2
test   $0x1,%r10b
jne    11e7 <get_specific_char+0xe7>
jmp    1222 <get_specific_char+0x122>

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

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