What is ":-!!" in C code?

Question

I bumped into this strange macro code in [/usr/include/linux/kernel.h][1]: /* Force a compilation error if condition is true, but also produce a result (of value 0 and type size_t), so the expression can be used e.g. in a structure initializer (or where-ever else comma expressions aren't permitted). */ #define BUILD_BUG_ON_ZERO(e) (sizeof(struct { int:-!!(e); })) #define BUILD_BUG_ON_NULL(e) ((void *)sizeof(struct { int:-!!(e); })) What does `:-!!` do? [1]: https://github.com/torvalds/linux/blob/ff2d8b19a3a62559afba1c53360c8577a7697714/include/linux/kernel.h#L677-L682

Answer 1

I'm just looking at it one step at a time.

Exclamation point ! is simply the basic C logical negation operator. It converts zero to 1 and all non-zero values to zero. -3, -2, -1, 1, 2, 3 all become zero.

If you apply it again with !!, a zero remains unchanged, while all non-zero value are converted to 1. -3, -2, -1, 1, 2, 3 all become 1.

If you then negate that with the basic C minus operator -, all non-zero values are converted to -1.

The "int:" is simply a struct bitfield of type int with a width in bits that follows. What happens when you try to define a bitfield with width -1 or -2 or -3? It's impossible. It's a compilation error.

Compilation will only succeed when `e' is 0 (false), consistent with the comment "Force a compilation error if condition is true."

Answer 2

":-!!" is not a single operator but four separate operators.

! is a logical negation

So for example !3 evaluates to zero.

!0 evaluates to 1.

Therefore !!3 evaluates to 1.

"-" takes the negative of that number.

The colon after an int in a struct definition defines the size of a bitfield.

int:0 is used to align the next structure member to the next int boundary.

unsigned char:0 will align the next structure member to the next byte boundary.

So, in the struct:

struct { unsigned char something:3;

unsigned char:0;

unsigned char something_else;};

something takes up 3 bits, and something_else takes up 8, but something_else starts on the next byte boundary, thanks to the unsigned char:0; member in between the two. It's a way of forcing data alignment.

So, you can't have a negative number for the size of a bit field...UNLESS THAT NUMBER IS ZERO.

What happens when that number is zero?

-0 == 0. Only number for which that is true.

Here we go. So if you define a macro that defines a structure with a single element

int:-!!(e);

And 'e' evaluates to anything other than 0, it will produce a build error. It won't compile.

The purpose of using this construct (perverse as it is) is to make sure code where 'e' does not evaluate to 0 does not even compile. It's a way of keeping bad code out of your operating system.

But (as the documentation says) it will produce a return result if e IS zero.

The question often arises -- why don't you just use an 'assert' or a 'try' or ...

Yah. Those things work great if you've got a functional operating system. But look at where this is being used: IN the operating system code: kernel.h.

You run out of bounds on that, and you no longer have a computer -- you've got bricked metal. So the idea behind using a construct like this are situations where you really need to prevent certain code from even compiling.