void crcAdvance(unsigned short crcPoly, unsigned short crcMask,
                unsigned short *crc, unsigned long bValue, int bBits) {
  int i;
  ;
  ;
  ;
  for (i = bBits - 1; i >= 0; i--) {
    unsigned short flag = (*crc) & crcMask ? 1 : 0;
    ;
    ;
    ;
    ;
    ;
    ;
    ;
    flag ^= (bValue & (1 << i) ? 1 : 0);
    ;
    ;
    (*crc) <<= 1;
    ;
    if (flag) {
      ;
      ;
      (*crc) ^= crcPoly;
    }
  };
}


x86 assembly (clang, -O0):
<crcAdvance>:
push   %rbp
mov    %rsp,%rbp
mov    %si,%ax
mov    %di,%si
mov    %si,-0x2(%rbp)
mov    %ax,-0x4(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x20(%rbp)
jl     11b5 <crcAdvance+0xb5>
mov    -0x10(%rbp),%rax
movzwl (%rax),%edx
movzwl -0x4(%rbp),%eax
and    %eax,%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %ax,-0x22(%rbp)
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
cltq
and    %rax,%rdx
xor    %ecx,%ecx
mov    $0x1,%eax
cmp    $0x0,%rdx
cmovne %eax,%ecx
movzwl -0x22(%rbp),%eax
xor    %ecx,%eax
mov    %ax,-0x22(%rbp)
mov    -0x10(%rbp),%rax
movzwl (%rax),%ecx
shl    $0x1,%ecx
mov    %cx,(%rax)
cmpw   $0x0,-0x22(%rbp)
je     11a2 <crcAdvance+0xa2>
movzwl -0x2(%rbp),%edx
mov    -0x10(%rbp),%rax
movzwl (%rax),%ecx
xor    %edx,%ecx
mov    %cx,(%rax)
jmp    11a7 <crcAdvance+0xa7>
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    1127 <crcAdvance+0x27>
pop    %rbp
ret

x86 assembly (clang, -O2):
<crcAdvance>:
test   %r8d,%r8d
jle    1159 <crcAdvance+0x59>
push   %rbx
mov    %rcx,%r9
movzwl (%rdx),%r11d
test   $0x1,%r8b
jne    111e <crcAdvance+0x1e>
mov    %r8d,%r10d
cmp    $0x1,%r8d
je     1154 <crcAdvance+0x54>
jmp    115a <crcAdvance+0x5a>
lea    -0x1(%r8),%r10d
test   %si,%r11w
setne  %al
mov    $0x1,%ebx
mov    %r10d,%ecx
shl    %cl,%ebx
movslq %ebx,%rcx
test   %r9,%rcx
setne  %cl
xor    %al,%cl
lea    (%r11,%r11,1),%eax
xor    %r11d,%r11d
test   %cl,%cl
cmovne %edi,%r11d
xor    %eax,%r11d
cmp    $0x1,%r8d
jne    115a <crcAdvance+0x5a>
mov    %r11w,(%rdx)
pop    %rbx
ret
add    $0xfffffffe,%r10d
jmp    116d <crcAdvance+0x6d>
xor    %eax,%r11d
add    $0xfffffffe,%r10d
cmp    $0x1,%r8d
jbe    1154 <crcAdvance+0x54>
lea    0x1(%r10),%r8d
test   %si,%r11w
setne  %al
mov    $0x1,%ebx
mov    %r8d,%ecx
shl    %cl,%ebx
movslq %ebx,%rcx
test   %r9,%rcx
setne  %bl
xor    %al,%bl
lea    (%r11,%r11,1),%ecx
mov    %edi,%eax
test   %bl,%bl
jne    1199 <crcAdvance+0x99>
xor    %eax,%eax
xor    %ecx,%eax
test   %si,%ax
setne  %r11b
mov    $0x1,%ebx
mov    %r10d,%ecx
shl    %cl,%ebx
movslq %ebx,%rcx
test   %r9,%rcx
setne  %cl
xor    %r11b,%cl
add    %eax,%eax
mov    %edi,%r11d
test   %cl,%cl
jne    1160 <crcAdvance+0x60>
xor    %r11d,%r11d
jmp    1160 <crcAdvance+0x60>

LLVM IR (-O0):
define void @crcAdvance(i16 zeroext %0, i16 zeroext %1, i16* %2, i64 %3, i32 %4) {
%6 = alloca i16
%7 = alloca i16
%8 = alloca i16*
%9 = alloca i64
%10 = alloca i32
%11 = alloca i32
%12 = alloca i16
store i16 %0, i16* %6
store i16 %1, i16* %7
store i16* %2, i16** %8
store i64 %3, i64* %9
store i32 %4, i32* %10
%13 = load i32, i32* %10
%14 = sub nsw i32 %13, 1
store i32 %14, i32* %11
br label %15
15: ; preds = %57, %5
%16 = load i32, i32* %11
%17 = icmp sge i32 %16, 0
br i1 %17, label %18, label %60
18: ; preds = %15
%19 = load i16*, i16** %8
%20 = load i16, i16* %19
%21 = zext i16 %20 to i32
%22 = load i16, i16* %7
%23 = zext i16 %22 to i32
%24 = and i32 %21, %23
%25 = icmp ne i32 %24, 0
%26 = zext i1 %25 to i64
%27 = select i1 %25, i32 1, i32 0
%28 = trunc i32 %27 to i16
store i16 %28, i16* %12
%29 = load i64, i64* %9
%30 = load i32, i32* %11
%31 = shl i32 1, %30
%32 = sext i32 %31 to i64
%33 = and i64 %29, %32
%34 = icmp ne i64 %33, 0
%35 = zext i1 %34 to i64
%36 = select i1 %34, i32 1, i32 0
%37 = load i16, i16* %12
%38 = zext i16 %37 to i32
%39 = xor i32 %38, %36
%40 = trunc i32 %39 to i16
store i16 %40, i16* %12
%41 = load i16*, i16** %8
%42 = load i16, i16* %41
%43 = zext i16 %42 to i32
%44 = shl i32 %43, 1
%45 = trunc i32 %44 to i16
store i16 %45, i16* %41
%46 = load i16, i16* %12
%47 = icmp ne i16 %46, 0
br i1 %47, label %48, label %56
48: ; preds = %18
%49 = load i16, i16* %6
%50 = zext i16 %49 to i32
%51 = load i16*, i16** %8
%52 = load i16, i16* %51
%53 = zext i16 %52 to i32
%54 = xor i32 %53, %50
%55 = trunc i32 %54 to i16
store i16 %55, i16* %51
br label %56
56: ; preds = %48, %18
br label %57
57: ; preds = %56
%58 = load i32, i32* %11
%59 = add nsw i32 %58, -1
store i32 %59, i32* %11
br label %15
60: ; preds = %15
ret void
}

LLVM IR (-O2):
define void @crcAdvance(i16 zeroext %0, i16 zeroext %1, i16* nocapture %2, i64 %3, i32 %4) {
%6 = icmp sgt i32 %4, 0
br i1 %6, label %7, label %56
7: ; preds = %5
%8 = load i16, i16* %2
%9 = and i32 %4, 1
%10 = icmp eq i32 %9, 0
br i1 %10, label %23, label %11
11: ; preds = %7
%12 = add nsw i32 %4, -1
%13 = and i16 %8, %1
%14 = icmp ne i16 %13, 0
%15 = shl nuw i32 1, %12
%16 = sext i32 %15 to i64
%17 = and i64 %16, %3
%18 = icmp ne i64 %17, 0
%19 = xor i1 %18, %14
%20 = shl i16 %8, 1
%21 = select i1 %19, i16 %0, i16 0
%22 = xor i16 %21, %20
br label %23
23: ; preds = %11, %7
%24 = phi i16 [ %8, %7 ], [ %22, %11 ]
%25 = phi i32 [ %4, %7 ], [ %12, %11 ]
%26 = phi i16 [ undef, %7 ], [ %22, %11 ]
%27 = icmp eq i32 %4, 1
br i1 %27, label %54, label %28
28: ; preds = %23, %28
%29 = phi i16 [ %52, %28 ], [ %24, %23 ]
%30 = phi i32 [ %42, %28 ], [ %25, %23 ]
%31 = add nsw i32 %30, -1
%32 = and i16 %29, %1
%33 = icmp ne i16 %32, 0
%34 = shl nuw i32 1, %31
%35 = sext i32 %34 to i64
%36 = and i64 %35, %3
%37 = icmp ne i64 %36, 0
%38 = xor i1 %37, %33
%39 = shl i16 %29, 1
%40 = select i1 %38, i16 %0, i16 0
%41 = xor i16 %40, %39
%42 = add nsw i32 %30, -2
%43 = and i16 %41, %1
%44 = icmp ne i16 %43, 0
%45 = shl nuw i32 1, %42
%46 = sext i32 %45 to i64
%47 = and i64 %46, %3
%48 = icmp ne i64 %47, 0
%49 = xor i1 %48, %44
%50 = shl i16 %41, 1
%51 = select i1 %49, i16 %0, i16 0
%52 = xor i16 %51, %50
%53 = icmp ugt i32 %31, 1
br i1 %53, label %28, label %54
54: ; preds = %28, %23
%55 = phi i16 [ %26, %23 ], [ %52, %28 ]
store i16 %55, i16* %2
br label %56
56: ; preds = %54, %5
ret void
}