uclinux-2008R1-RC8(bf561)到VDSP5的移植(35)：ARRAY_SIZE

 

  

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

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

这个宏定义用于取得一个数组中元素的个数，与一般定义不同的是，这个定义加上了+ __must_be_array(arr)这个尾巴，看下它的定义：

 

/* 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(char[1 - 2 * !!(e)]) - 1)

 

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

#define __must_be_array(a) /

 BUILD_BUG_ON_ZERO(__builtin_types_compatible_p(typeof(a), typeof(&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 type1 and 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;                                                        /

            })

    

Note: This construct is only available for C.

它返回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的原因。

ARRAY_SIZE这样的定义在VDSP中是无法通过的，但是由于__must_be_array(arr)的作用仅仅在于添加一个编译时的检查，我们直接改为：

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