What does sizeof(int[1]) mean?

Question

I am new to the Linux kernel. I am reading the file ioctl.h , there I encountered a macro _IOC_TYPECHECK(t) , which looks like this:

#define _IOC_TYPECHECK(t) \
        ((sizeof(t) == sizeof(t[1]) && \
          sizeof(t) < (1 << _IOC_SIZEBITS)) ? \
          sizeof(t) : __invalid_size_argument_for_IOC)

Can you explain me this code? In this code, what does sizeof(t[1]) mean?

Answer 1

This is used to check the validity of the third parameter to the _IOR / _IOW / _IOWR macros, which is supposed to be a type. It checks that the parameter is actually a type (and not a variable or a number), and causes a compiler or linker error otherwise.

• If t is a type, then t[1] is the type "an array of 1 t ". This type has the same size as t , and therefore sizeof(t) == sizeof(t[1]) is true.

• If t is a number, sizeof(t) will fail to compile.

• If t is a simple (non-array) variable, then t[1] will cause a compiler error.

• If t is an array variable, sizeof(t) == sizeof(t[1]) will be false, and a linker error will be caused (because __invalid_size_argument_for_IOC is not defined).

The expression sizeof(t) < (1 << _IOC_SIZEBITS) checks that the size of the type t does not exceed the maximum allowed for ioctl , and causes the same linker error otherwise.

There are still some invalid cases which will not be caught by this macro - for example, when t is a pointer to a pointer.

Answer 2

It means the same as all other uses of sizeof . It computes the size of the expression.

In this particular case, I suspect that the check is intended to ensure some property of t (which should be a type name, not a variable) which I don't know from the context ... Perhaps that it's possible to treat it as a pointer (needed for the array indexing) which would rule out some types. The comment next to the macro says /* provoke compile error for invalid uses of size argument */ which seems to support this theory.

Note that sizeof is an operator, not a function. The parenthesis are not needed, except when you want to compute the size of a type directly, and then they're part of the expression (it's a cast expression). So this could be written sizeof t == sizeof t[1] && ... , or maybe (sizeof t == sizeof t[1]) for clarity.

This is a very good style to use, since it "locks" the size being computed to the proper array, instead of repeating the type of t . So, if the type were to change, the expression would automatically adapt and still compute the right thing.

Many C programmers seem to prefer having parenthesis around the argument to sizeof in all cases, for some reason.