Linux3.5的部分宏定义在Linux-3.5/include/linux/kernel.h的头文件中有定义
一： 最大值和最小值相关的宏
1. /*
2. * min()/max()/clamp() macros that also do
3. * strict type-checking.. See the
4. * "unnecessary" pointer comparison.
5. */
6. #define min(x, y) ({ \
7. typeof(x) _min1 = (x); \
8. typeof(y) _min2 = (y); \
9. void) (&_min1 == &_min2); \
10. _min1 < _min2 ? _min1 : _min2; })
11.
12. #define max(x, y) ({ \
13. typeof(x) _max1 = (x); \
14. typeof(y) _max2 = (y); \
15. void) (&_max1 == &_max2); \
16. _max1 > _max2 ? _max1 : _max2; })
17.
18. #define min3(x, y, z) ({ \
19. typeof(x) _min1 = (x); \
20. typeof(y) _min2 = (y); \
21. typeof(z) _min3 = (z); \
22. void) (&_min1 == &_min2); \
23. void) (&_min1 == &_min3); \
24. _min1 < _min2 ? (_min1 < _min3 ? _min1 : _min3) : \
25. (_min2 < _min3 ? _min2 : _min3); })
26.
27. #define max3(x, y, z) ({ \
28. typeof(x) _max1 = (x); \
29. typeof(y) _max2 = (y); \
30. typeof(z) _max3 = (z); \
31. void) (&_max1 == &_max2); \
32. void) (&_max1 == &_max3); \
33. _max1 > _max2 ? (_max1 > _max3 ? _max1 : _max3) : \
34. (_max2 > _max3 ? _max2 : _max3); })
以上几个宏会做严格的类型检查
(void) (&_min1 == &_min2);
表面看起来，这句话，好像不起作用，算是一句废话，其实作用还是比较大的。首先，我们此处想要实现的目的是，在计算两个数的最小值之前，希望去判断一下两个值的类型是否一致，而由于C语言本身不支持我们去做类似于这样的操作typeof(_x)==typeof(_y)，所以在此，通过故意判断他们2个的地址指针是否相等，而显然&_x，即x的地址，是不可能等于&_y的，但是这句话(void) (&_x == &_y);使得，如果_x和_y的类型不一样，其指针类型也会不一样，2个不一样的指针类型进行比较操作，则会引起编译器产生一个编译警告，提示你这两个值的类型不同。通过void显式丢弃一个表达式的值，否则有些编译器会就此给出警告信息。
比如看看如下代码：
编译的时候，经过预处理后，就会有这样的判断操作：
int * == char *;
因此编译器就会提示你：
warning: comparison of distinct pointer types lacks a cast(警告：比较不相关的指针时缺少类型转换)
所以，这个宏的巧妙之处就在于此。
所以，总结起来就是：
【提示】
1。其实关于min的宏，更好的做法是再加个const，即：
1. #define min(x, y) ({ \
2. const typeof(x) _min1 = (x); \
3. const typeof(y) _min2 = (y); \
4. void) (&_min1 == &_min2); \
5. _min1 < _min2 ? _min1 : _min2; })
2。(void) (&_x == &_y); 中的void，表示将表达式(&_x == &_y); 所得到的结果（此处肯定是逻辑上的假，值为0）忽略掉。如果不加void，则会提示你这行代码是无意义的，没人用到，有些编译器会产生警告信息。
3。关于min的宏定义，为何这么复杂，而不是用简单的#define min(x,y) ((x) < (y) ? x : y)
因为，如果如此定义，那么对于一些特殊的值传入此宏之后，就会产生一些副作用，产生的结果，就不是我们想要的了，比如：
min(++a,++b) ==> ((++a)<(++b))?(++a) : (++b)
就使得，a++和b++分别执行了2次，而且min的结果，也不对了。而用上面那个复杂的定义，多加了局部变量_x和_y,就可以避免此类问题了。
二、 其它相关宏的分析
swap是交换两个变量的值的宏，可以支持所有的基本类型。
1. /**
2. * min_not_zero - return the minimum that is _not_ zero, unless both are zero
3. * @x: value1
4. * @y: value2
5. */
6. #define min_not_zero(x, y) ({ \
7. typeof(x) __x = (x); \
8. typeof(y) __y = (y); \
9. __x == 0 ? __y : ((__y == 0) ? __x : min(__x, __y)); })
10.
11. /*
12. * ..and if you can't take the strict
13. * types, you can specify one yourself.
14. *
15. * Or not use min/max/clamp at all, of course.
16. */
17. #define min_t(type, x, y) ({ \
18. type __min1 = (x); \
19. type __min2 = (y); \
20. __min1 < __min2 ? __min1: __min2; })
21.
22. #define max_t(type, x, y) ({ \
23. type __max1 = (x); \
24. type __max2 = (y); \
25. __max1 > __max2 ? __max1: __max2; })
26.
27. /*
28. * swap - swap value of @a and @b
29. */
30. #define swap(a, b) \
31. do { typeof(a) __tmp = (a); (a) = (b); (b) = __tmp; } while (0)
