int countbits(unsigned int n) {
  int q = n;
  q = (q & 0x5555555555555555) + ((q & 0xAAAAAAAAAAAAAAAA) >> 1);
  q = (q & 0x3333333333333333) + ((q & 0xCCCCCCCCCCCCCCCC) >> 2);
  q = (q & 0x0F0F0F0F0F0F0F0F) + ((q & 0xF0F0F0F0F0F0F0F0) >> 4);
  q = (q & 0x00FF00FF00FF00FF) + ((q & 0xFF00FF00FF00FF00) >> 8);
  q = (q & 0x0000FFFF0000FFFF) + ((q & 0xFFFF0000FFFF0000) >> 16);
  q = (q & 0x00000000FFFFFFFF) + ((q & 0xFFFFFFFF00000000) >> 32);
  return q;
}


x86 assembly (clang, -O0):
<countbits>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x8(%rbp)
movslq -0x8(%rbp),%rax
movabs $0x5555555555555555,%rcx
55 55 55
and    %rcx,%rax
movslq -0x8(%rbp),%rcx
movabs $0xaaaaaaaaaaaaaaaa,%rdx
aa aa aa
and    %rdx,%rcx
shr    $0x1,%rcx
add    %rcx,%rax
mov    %eax,-0x8(%rbp)
movslq -0x8(%rbp),%rax
movabs $0x3333333333333333,%rcx
33 33 33
and    %rcx,%rax
movslq -0x8(%rbp),%rcx
movabs $0xcccccccccccccccc,%rdx
cc cc cc
and    %rdx,%rcx
shr    $0x2,%rcx
add    %rcx,%rax
mov    %eax,-0x8(%rbp)
movslq -0x8(%rbp),%rax
movabs $0xf0f0f0f0f0f0f0f,%rcx
0f 0f 0f
and    %rcx,%rax
movslq -0x8(%rbp),%rcx
movabs $0xf0f0f0f0f0f0f0f0,%rdx
f0 f0 f0
and    %rdx,%rcx
shr    $0x4,%rcx
add    %rcx,%rax
mov    %eax,-0x8(%rbp)
movslq -0x8(%rbp),%rax
movabs $0xff00ff00ff00ff,%rcx
and    %rcx,%rax
movslq -0x8(%rbp),%rcx
movabs $0xff00ff00ff00ff00,%rdx
and    %rdx,%rcx
shr    $0x8,%rcx
add    %rcx,%rax
mov    %eax,-0x8(%rbp)
movslq -0x8(%rbp),%rax
movabs $0xffff0000ffff,%rcx
and    %rcx,%rax
movslq -0x8(%rbp),%rcx
movabs $0xffff0000ffff0000,%rdx
and    %rdx,%rcx
shr    $0x10,%rcx
add    %rcx,%rax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
and    $0xffffffff,%eax
mov    %eax,%eax
movslq -0x8(%rbp),%rcx
movabs $0xffffffff00000000,%rdx
ff ff ff
and    %rdx,%rcx
shr    $0x20,%rcx
add    %rcx,%rax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<countbits>:
mov    %edi,%eax
mov    %eax,%ecx
and    $0x55555555,%ecx
shr    %rax
and    $0x55555555,%eax
add    %rcx,%rax
mov    %eax,%ecx
and    $0x33333333,%ecx
shr    $0x2,%rax
and    $0x33333333,%eax
add    %rcx,%rax
mov    %eax,%ecx
and    $0x7070707,%ecx
shr    $0x4,%rax
and    $0x7070707,%eax
add    %rcx,%rax
mov    %eax,%ecx
and    $0xf000f,%ecx
shr    $0x8,%rax
and    $0xf000f,%eax
add    %rcx,%rax
movzwl %ax,%ecx
shr    $0x10,%rax
add    %ecx,%eax
ret

LLVM IR (-O0):
define i32 @countbits(i32 %0) {
%2 = alloca i32
%3 = alloca i32
store i32 %0, i32* %2
%4 = load i32, i32* %2
store i32 %4, i32* %3
%5 = load i32, i32* %3
%6 = sext i32 %5 to i64
%7 = and i64 %6, 6148914691236517205
%8 = load i32, i32* %3
%9 = sext i32 %8 to i64
%10 = and i64 %9, -6148914691236517206
%11 = lshr i64 %10, 1
%12 = add i64 %7, %11
%13 = trunc i64 %12 to i32
store i32 %13, i32* %3
%14 = load i32, i32* %3
%15 = sext i32 %14 to i64
%16 = and i64 %15, 3689348814741910323
%17 = load i32, i32* %3
%18 = sext i32 %17 to i64
%19 = and i64 %18, -3689348814741910324
%20 = lshr i64 %19, 2
%21 = add i64 %16, %20
%22 = trunc i64 %21 to i32
store i32 %22, i32* %3
%23 = load i32, i32* %3
%24 = sext i32 %23 to i64
%25 = and i64 %24, 1085102592571150095
%26 = load i32, i32* %3
%27 = sext i32 %26 to i64
%28 = and i64 %27, -1085102592571150096
%29 = lshr i64 %28, 4
%30 = add i64 %25, %29
%31 = trunc i64 %30 to i32
store i32 %31, i32* %3
%32 = load i32, i32* %3
%33 = sext i32 %32 to i64
%34 = and i64 %33, 71777214294589695
%35 = load i32, i32* %3
%36 = sext i32 %35 to i64
%37 = and i64 %36, -71777214294589696
%38 = lshr i64 %37, 8
%39 = add i64 %34, %38
%40 = trunc i64 %39 to i32
store i32 %40, i32* %3
%41 = load i32, i32* %3
%42 = sext i32 %41 to i64
%43 = and i64 %42, 281470681808895
%44 = load i32, i32* %3
%45 = sext i32 %44 to i64
%46 = and i64 %45, -281470681808896
%47 = lshr i64 %46, 16
%48 = add i64 %43, %47
%49 = trunc i64 %48 to i32
store i32 %49, i32* %3
%50 = load i32, i32* %3
%51 = and i32 %50, -1
%52 = zext i32 %51 to i64
%53 = load i32, i32* %3
%54 = sext i32 %53 to i64
%55 = and i64 %54, -4294967296
%56 = lshr i64 %55, 32
%57 = add i64 %52, %56
%58 = trunc i64 %57 to i32
store i32 %58, i32* %3
%59 = load i32, i32* %3
ret i32 %59
}

LLVM IR (-O2):
define i32 @countbits(i32 %0) {
%2 = zext i32 %0 to i64
%3 = and i64 %2, 1431655765
%4 = lshr i64 %2, 1
%5 = and i64 %4, 1431655765
%6 = add nuw nsw i64 %5, %3
%7 = and i64 %6, 858993459
%8 = lshr i64 %6, 2
%9 = and i64 %8, 858993459
%10 = add nuw nsw i64 %9, %7
%11 = and i64 %10, 117901063
%12 = lshr i64 %10, 4
%13 = and i64 %12, 117901063
%14 = add nuw nsw i64 %13, %11
%15 = and i64 %14, 983055
%16 = lshr i64 %14, 8
%17 = and i64 %16, 983055
%18 = add nuw nsw i64 %17, %15
%19 = and i64 %18, 31
%20 = lshr i64 %18, 16
%21 = add nuw nsw i64 %19, %20
%22 = trunc i64 %21 to i32
ret i32 %22
}