1 /* SPDX-License-Identifier: GPL-2.0 */ 2 #ifndef _LINUX_MINMAX_H 3 #define _LINUX_MINMAX_H 4 5 /* 6 * min()/max()/clamp() macros must accomplish three things: 7 * 8 * - avoid multiple evaluations of the arguments (so side-effects like 9 * "x++" happen only once) when non-constant. 10 * - perform strict type-checking (to generate warnings instead of 11 * nasty runtime surprises). See the "unnecessary" pointer comparison 12 * in __typecheck(). 13 * - retain result as a constant expressions when called with only 14 * constant expressions (to avoid tripping VLA warnings in stack 15 * allocation usage). 16 */ 17 #define __typecheck(x, y) \ 18 (!!(sizeof((typeof(x) *)1 == (typeof(y) *)1))) 19 20 /* 21 * This returns a constant expression while determining if an argument is 22 * a constant expression, most importantly without evaluating the argument. 23 * Glory to Martin Uecker <Martin.Uecker@med.uni-goettingen.de> 24 */ 25 #define __is_constexpr(x) \ 26 (sizeof(int) == sizeof(*(8 ? ((void *)((long)(x) * 0l)) : (int *)8))) 27 28 #define __no_side_effects(x, y) \ 29 (__is_constexpr(x) && __is_constexpr(y)) 30 31 #define __safe_cmp(x, y) \ 32 (__typecheck(x, y) && __no_side_effects(x, y)) 33 34 #define __cmp(x, y, op) ((x) op (y) ? (x) : (y)) 35 36 #define __cmp_once(x, y, unique_x, unique_y, op) ({ \ 37 typeof(x) unique_x = (x); \ 38 typeof(y) unique_y = (y); \ 39 __cmp(unique_x, unique_y, op); }) 40 41 #define __careful_cmp(x, y, op) \ 42 __builtin_choose_expr(__safe_cmp(x, y), \ 43 __cmp(x, y, op), \ 44 __cmp_once(x, y, __UNIQUE_ID(__x), __UNIQUE_ID(__y), op)) 45 46 /** 47 * min - return minimum of two values of the same or compatible types 48 * @x: first value 49 * @y: second value 50 */ 51 #define min(x, y) __careful_cmp(x, y, <) 52 53 /** 54 * max - return maximum of two values of the same or compatible types 55 * @x: first value 56 * @y: second value 57 */ 58 #define max(x, y) __careful_cmp(x, y, >) 59 60 /** 61 * min3 - return minimum of three values 62 * @x: first value 63 * @y: second value 64 * @z: third value 65 */ 66 #define min3(x, y, z) min((typeof(x))min(x, y), z) 67 68 /** 69 * max3 - return maximum of three values 70 * @x: first value 71 * @y: second value 72 * @z: third value 73 */ 74 #define max3(x, y, z) max((typeof(x))max(x, y), z) 75 76 /** 77 * min_not_zero - return the minimum that is _not_ zero, unless both are zero 78 * @x: value1 79 * @y: value2 80 */ 81 #define min_not_zero(x, y) ({ \ 82 typeof(x) __x = (x); \ 83 typeof(y) __y = (y); \ 84 __x == 0 ? __y : ((__y == 0) ? __x : min(__x, __y)); }) 85 86 /** 87 * clamp - return a value clamped to a given range with strict typechecking 88 * @val: current value 89 * @lo: lowest allowable value 90 * @hi: highest allowable value 91 * 92 * This macro does strict typechecking of @lo/@hi to make sure they are of the 93 * same type as @val. See the unnecessary pointer comparisons. 94 */ 95 #define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi) 96 97 /* 98 * ..and if you can't take the strict 99 * types, you can specify one yourself. 100 * 101 * Or not use min/max/clamp at all, of course. 102 */ 103 104 /** 105 * min_t - return minimum of two values, using the specified type 106 * @type: data type to use 107 * @x: first value 108 * @y: second value 109 */ 110 #define min_t(type, x, y) __careful_cmp((type)(x), (type)(y), <) 111 112 /** 113 * max_t - return maximum of two values, using the specified type 114 * @type: data type to use 115 * @x: first value 116 * @y: second value 117 */ 118 #define max_t(type, x, y) __careful_cmp((type)(x), (type)(y), >) 119 120 /** 121 * clamp_t - return a value clamped to a given range using a given type 122 * @type: the type of variable to use 123 * @val: current value 124 * @lo: minimum allowable value 125 * @hi: maximum allowable value 126 * 127 * This macro does no typechecking and uses temporary variables of type 128 * @type to make all the comparisons. 129 */ 130 #define clamp_t(type, val, lo, hi) min_t(type, max_t(type, val, lo), hi) 131 132 /** 133 * clamp_val - return a value clamped to a given range using val's type 134 * @val: current value 135 * @lo: minimum allowable value 136 * @hi: maximum allowable value 137 * 138 * This macro does no typechecking and uses temporary variables of whatever 139 * type the input argument @val is. This is useful when @val is an unsigned 140 * type and @lo and @hi are literals that will otherwise be assigned a signed 141 * integer type. 142 */ 143 #define clamp_val(val, lo, hi) clamp_t(typeof(val), val, lo, hi) 144 145 /** 146 * swap - swap values of @a and @b 147 * @a: first value 148 * @b: second value 149 */ 150 #define swap(a, b) \ 151 do { typeof(a) __tmp = (a); (a) = (b); (b) = __tmp; } while (0) 152 153 #endif /* _LINUX_MINMAX_H */ 154
