Bit manipulation and Flags testing in C

Question

Suppose I have two variables of type int, a and b, and a flag F.

#define F <something>

int a = <something> ;
int b = <something> ;

What is a simple way to test that both a and b, have the flag F, or none of them has it?

To test if both of them have it, I can use something like:

if ( a & b & F )

To test if none of them has it, I can use something like:

if ( !((a & F) || (b & F)) )

And the whole test becomes:

if ( (a & b & F) &&  !((a & F) || (b & F)) )

But this looks, too long and too complicated. Is there any simpler solution?

Is it granteed that exactly one bit in `F` is 1, or none or multiple bits in `F` can be 1? — MikeCAT, Aug 19 '17 at 13:15

score 3 · Accepted Answer · answered Aug 19 '17 at 13:04

3

The test for "none of them has it" can be

!((a | b) & F)

Merge the flags, mask and flip the logic.

The whole test can be written using xor. (Thanks to Martin James for the idea)

!((a ^ b) & F)

This means "not (exactly one of a or b has F)"

answered Aug 19 '17 at 13:04

MikeCAT

73,922
11
45
70

`!((a | b) & F)` Is this De Morgan's laws? because I think `!((a | b) & F)` is equivalent to `!( (a&F) | (b&F) )` and not `!( (a&F) || (b&F) )` – Bite Bytes Aug 19 '17 at 13:09
@BiteBytes None of `!( (a&F) | (a&F) )` and `!( (a&F) || (a&F) )` is equivalent to `!((a | b) & F)`: both of the first two uses `a` twice while the last one uses `a` and `b`. – MikeCAT Aug 19 '17 at 13:11
@BiteBytes `(a | b) & F` is equivalent to `(a & F) | (b & F)` and isn't equivalent to `(a & F) || (b & F)`, the difference is that `|` operator does bitwise OR and `||` operator does logic OR. But adding `!` operator, which does logic NOT, to all of them, all should be equivalent. – MikeCAT Aug 19 '17 at 13:18

Sergey Kalinichenko · Answer 2 · 2017-08-19T13:56:10.453

2

You are looking for bit equality, which can be tested by applying XOR operator ^, inverting the result, and masking.

a ^ b sets bits to 1 only where the corresponding bits of a and b are different. For corresponding bits that are the same the result bit will be set to zero.

If you invert the result, you'd get ones in positions of equal bits:

~(a ^ b)

The only thing that remains is to mask with F, and check for equality:

if ((~(a ^ b) & F) == F) {
    ... // All bits indicated by F are set to the same value in a and b
}

edited Aug 19 '17 at 13:56

answered Aug 19 '17 at 13:10

Sergey Kalinichenko

714,442
84
1,110
1,523

why checking for equality? wouldn't `if (~(a ^ b) & F))` be enough? – Bite Bytes Aug 19 '17 at 13:20
Without an equality check at the end you would get a "true" when some, but not necessarily all, the bits have a match. It would also not work for F of zero (when no bits are checked the answer should be "true"). – Sergey Kalinichenko Aug 19 '17 at 13:24
`~(a ^ b) & F == F` - it is incorrect it is the same as `~(a ^ b) & 1` – 0___________ Aug 19 '17 at 13:33
@dasblinkenlight even when corrected it gives the worst code :) https://godbolt.org/g/8ugA7r – 0___________ Aug 19 '17 at 13:40
1

operator precedence issue: change `~(a ^ b) & F == F)` to `(~(a ^ b) & F) == F)`, which is decidedly less readable than `!((a ^ b) & F)` – chqrlie Aug 19 '17 at 13:43
@PeterJ why is that? `==` has lower precedence than `&`. – Bite Bytes Aug 19 '17 at 13:50

score 2 · Answer 3 · answered Aug 19 '17 at 13:18

2

Maybe this one

!((a & F) ^ (b & F))

answered Aug 19 '17 at 13:18

0___________

60,014
4
34
74

1

More readable but possibly one more opcode than `!((a ^ b) & F)`. Also a bit error prone as the elegant symmetry might make the reader assume that it would work for different flags as in `!((a & F1) ^ (b & F2))` which is not true. – chqrlie Aug 19 '17 at 13:21
Yes - it is intentional as OP is learning bitwise operations. It gives the same output despite of optimisation level. https://godbolt.org/g/SmXL9N – 0___________ Aug 19 '17 at 13:25
interesting how gcc unlike clang produces the same code at `-O0` and clang produces the same code at `-O2` unlike gcc that shares the code with a `jmp`. – chqrlie Aug 19 '17 at 13:32
1

@chqrlie the chosen solution does not work :) and produces when corrected the worst code – 0___________ Aug 19 '17 at 13:37
@chqrlie I have tested only gcc – 0___________ Aug 19 '17 at 14:12

Bit manipulation and Flags testing in C

3 Answers3