unsigned char bits_to_byte(char bt0, char bt1, char bt2, char bt3, char bt4,
                           char bt5, char bt6, char bt7) {
  unsigned char rbyte;
  rbyte = (unsigned char)(bt0 + (2 * bt1) + (4 * bt2) + (8 * bt3) + (16 * bt4) +
                          (32 * bt5) + (64 * bt6) + (128 * bt7));
  return (rbyte);
}


x86 assembly (clang, -O0):
<bits_to_byte>:
push   %rbp
mov    %rsp,%rbp
mov    %r8d,-0x18(%rbp)
mov    %ecx,%eax
mov    -0x18(%rbp),%ecx
mov    %eax,-0x14(%rbp)
mov    %edx,%eax
mov    -0x14(%rbp),%edx
mov    %eax,-0x10(%rbp)
mov    %esi,%eax
mov    -0x10(%rbp),%esi
mov    %eax,-0xc(%rbp)
mov    %edi,%r8d
mov    -0xc(%rbp),%edi
mov    %r9b,%al
mov    0x18(%rbp),%r9b
mov    0x10(%rbp),%r9b
mov    %r8b,-0x1(%rbp)
mov    %dil,-0x2(%rbp)
mov    %sil,-0x3(%rbp)
mov    %dl,-0x4(%rbp)
mov    %cl,-0x5(%rbp)
mov    %al,-0x6(%rbp)
movsbl -0x1(%rbp),%eax
movsbl -0x2(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
movsbl -0x3(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%eax
movsbl -0x4(%rbp),%ecx
shl    $0x3,%ecx
add    %ecx,%eax
movsbl -0x5(%rbp),%ecx
shl    $0x4,%ecx
add    %ecx,%eax
movsbl -0x6(%rbp),%ecx
shl    $0x5,%ecx
add    %ecx,%eax
movsbl 0x10(%rbp),%ecx
shl    $0x6,%ecx
add    %ecx,%eax
movsbl 0x18(%rbp),%ecx
shl    $0x7,%ecx
add    %ecx,%eax
mov    %al,-0x7(%rbp)
movzbl -0x7(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<bits_to_byte>:
mov    0x10(%rsp),%al
mov    0x8(%rsp),%r10b
add    %esi,%esi
add    %dil,%sil
lea    0x0(,%rdx,4),%edx
add    %sil,%dl
lea    0x0(,%rcx,8),%ecx
add    %dl,%cl
shl    $0x4,%r8b
add    %r8b,%cl
shl    $0x5,%r9b
add    %r9b,%cl
shl    $0x6,%r10b
add    %cl,%r10b
shl    $0x7,%al
add    %r10b,%al
ret

LLVM IR (-O0):
define zeroext i8 @bits_to_byte(i8 signext %0, i8 signext %1, i8 signext %2, i8 signext %3, i8 signext %4, i8 signext %5, i8 signext %6, i8 signext %7) {
%9 = alloca i8
%10 = alloca i8
%11 = alloca i8
%12 = alloca i8
%13 = alloca i8
%14 = alloca i8
%15 = alloca i8
%16 = alloca i8
%17 = alloca i8
store i8 %0, i8* %9
store i8 %1, i8* %10
store i8 %2, i8* %11
store i8 %3, i8* %12
store i8 %4, i8* %13
store i8 %5, i8* %14
store i8 %6, i8* %15
store i8 %7, i8* %16
%18 = load i8, i8* %9
%19 = sext i8 %18 to i32
%20 = load i8, i8* %10
%21 = sext i8 %20 to i32
%22 = mul nsw i32 2, %21
%23 = add nsw i32 %19, %22
%24 = load i8, i8* %11
%25 = sext i8 %24 to i32
%26 = mul nsw i32 4, %25
%27 = add nsw i32 %23, %26
%28 = load i8, i8* %12
%29 = sext i8 %28 to i32
%30 = mul nsw i32 8, %29
%31 = add nsw i32 %27, %30
%32 = load i8, i8* %13
%33 = sext i8 %32 to i32
%34 = mul nsw i32 16, %33
%35 = add nsw i32 %31, %34
%36 = load i8, i8* %14
%37 = sext i8 %36 to i32
%38 = mul nsw i32 32, %37
%39 = add nsw i32 %35, %38
%40 = load i8, i8* %15
%41 = sext i8 %40 to i32
%42 = mul nsw i32 64, %41
%43 = add nsw i32 %39, %42
%44 = load i8, i8* %16
%45 = sext i8 %44 to i32
%46 = mul nsw i32 128, %45
%47 = add nsw i32 %43, %46
%48 = trunc i32 %47 to i8
store i8 %48, i8* %17
%49 = load i8, i8* %17
ret i8 %49
}

LLVM IR (-O2):
define zeroext i8 @bits_to_byte(i8 signext %0, i8 signext %1, i8 signext %2, i8 signext %3, i8 signext %4, i8 signext %5, i8 signext %6, i8 signext %7) {
%9 = shl i8 %1, 1
%10 = add i8 %9, %0
%11 = shl i8 %2, 2
%12 = add i8 %10, %11
%13 = shl i8 %3, 3
%14 = add i8 %12, %13
%15 = shl i8 %4, 4
%16 = add i8 %14, %15
%17 = shl i8 %5, 5
%18 = add i8 %16, %17
%19 = shl i8 %6, 6
%20 = add i8 %18, %19
%21 = shl i8 %7, 7
%22 = add i8 %20, %21
ret i8 %22
}