在include/linux/kernel.h中有一个定义：

#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]) + __must_be_array(arr))

这个宏定义用于取得一个数组中元素的个数，与一般定义不同的是，这个定义加上了+ __must_be_array(arr)这个尾巴，这个定义同时存在于两个文件中,分别针对GCC和ECC(intel的编译器).它的定义：

1.在include/linux/compiler-gcc.h中:

/* &a[0] degrades to a pointer: a different type from an array */

&a[0]是一个指针,指向不同于这个数组的类型.

#define __must_be_array(a) \

BUILD_BUG_ON_ZERO(__builtin_types_compatible_p(typeof(a), typeof(&a[0])))

/* 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). */

当条件为真时强制产生一个编译错误,但也要产生一个结构(值0和size_t类型),这个表达式可以用在例如在结构体初始化程序(或是在不允许使用逗号表达式的地方).

#define BUILD_BUG_ON_ZERO(e) (sizeof(char[1 - 2 * !!(e)]) - 1)

__builtin_types_compatible_p:

gcc内嵌函数用于判断一个变量的类型是否为某指定的类型，假如是就返回1，否则返回0。

它返回0或者1的结果，把它代入到BUILD_BUG_ON_ZERO定义中就可以发现，当返回值为0时，BUILD_BUG_ON_ZERO就变成了

#define BUILD_BUG_ON_ZERO(e) (sizeof(char[1]) - 1)

显然，此时BUILD_BUG_ON_ZERO这个宏将返回0。而当__builtin_types_compatible_p为1时，BUILD_BUG_ON_ZERO就变成了

#define BUILD_BUG_ON_ZERO(e) (sizeof(char[-1]) - 1)

显然会造成语法错误，这也是注释中说明"Force a compilation error"的原因。

而这个char的定义在同文件中可以找到,如下:

extern const char linux_banner[];

那么这个linux_banner[]又是什么呢?

在init/version.c中有如下的定义:

/* FIXED STRINGS! Don't touch! */

const char linux_banner[] =

"Linux version " UTS_RELEASE " (" LINUX_COMPILE_BY "@"

LINUX_COMPILE_HOST ") (" LINUX_COMPILER ") " UTS_VERSION "\n";

2.在include/linux/compiler-intel.h中:

/* Intel ECC compiler doesn't support __builtin_types_compatible_p() */

因为Intel的ECC编译器不支持__builtin_types_compatible_p所以直接定义为0

#define __must_be_array(a) 0

以下搜自网络:

在这里__builtin_types_compatible_p是gcc内置的一个定义，对它的作用有这样一个说明：

— Built-in Function: int __builtin_types_compatible_p(type1, type2)

You can use the built-in function __builtin_types_compatible_p to determine whether two types are the same.

This built-in function returns 1 if the unqualified versions of the types type1and type2(which are types, not expressions) are compatible, 0 otherwise. The result of this built-in function can be used in integer constant expressions.

This built-in function ignores top level qualifiers (e.g., const, volatile). For example, int is equivalent to const int.

The type int[] and int[5] are compatible. On the other hand, int and char * are not compatible, even if the size of their types, on the particular architecture are the same. Also, the amount of pointer indirection is taken into account when determining similarity. Consequently, short * is not similar to short **. Furthermore, two types that are typedefed are considered compatible if their underlying types are compatible.

An enum type is considered to be compatible with another enum type. For example, enum {foo, bar} is similar to enum {hot, dog}.

You would typically use this function in code whose execution varies depending on the arguments' types. For example:

#define foo(x)                                                  \

({                                                           \

typeof (x) tmp;                                              \

if (__builtin_types_compatible_p (typeof (x), long double)) \

tmp = foo_long_double (tmp);                              \

else if (__builtin_types_compatible_p (typeof (x), double)) \

tmp = foo_double (tmp);                                   \

else if (__builtin_types_compatible_p (typeof (x), float)) \

tmp = foo_float (tmp);                                    \

else                                                         \

abort ();                                                 \

tmp;                                                        \

})