165 строки
4.4 KiB
C
165 строки
4.4 KiB
C
/* SPDX-License-Identifier: GPL-2.0 */
|
|
#ifndef _LINUX_MINMAX_H
|
|
#define _LINUX_MINMAX_H
|
|
|
|
#include <linux/const.h>
|
|
|
|
/*
|
|
* min()/max()/clamp() macros must accomplish three things:
|
|
*
|
|
* - avoid multiple evaluations of the arguments (so side-effects like
|
|
* "x++" happen only once) when non-constant.
|
|
* - perform strict type-checking (to generate warnings instead of
|
|
* nasty runtime surprises). See the "unnecessary" pointer comparison
|
|
* in __typecheck().
|
|
* - retain result as a constant expressions when called with only
|
|
* constant expressions (to avoid tripping VLA warnings in stack
|
|
* allocation usage).
|
|
*/
|
|
#define __typecheck(x, y) \
|
|
(!!(sizeof((typeof(x) *)1 == (typeof(y) *)1)))
|
|
|
|
#define __no_side_effects(x, y) \
|
|
(__is_constexpr(x) && __is_constexpr(y))
|
|
|
|
#define __safe_cmp(x, y) \
|
|
(__typecheck(x, y) && __no_side_effects(x, y))
|
|
|
|
#define __cmp(x, y, op) ((x) op (y) ? (x) : (y))
|
|
|
|
#define __cmp_once(x, y, unique_x, unique_y, op) ({ \
|
|
typeof(x) unique_x = (x); \
|
|
typeof(y) unique_y = (y); \
|
|
__cmp(unique_x, unique_y, op); })
|
|
|
|
#define __careful_cmp(x, y, op) \
|
|
__builtin_choose_expr(__safe_cmp(x, y), \
|
|
__cmp(x, y, op), \
|
|
__cmp_once(x, y, __UNIQUE_ID(__x), __UNIQUE_ID(__y), op))
|
|
|
|
/**
|
|
* min - return minimum of two values of the same or compatible types
|
|
* @x: first value
|
|
* @y: second value
|
|
*/
|
|
#define min(x, y) __careful_cmp(x, y, <)
|
|
|
|
/**
|
|
* max - return maximum of two values of the same or compatible types
|
|
* @x: first value
|
|
* @y: second value
|
|
*/
|
|
#define max(x, y) __careful_cmp(x, y, >)
|
|
|
|
/**
|
|
* umin - return minimum of two non-negative values
|
|
* Signed types are zero extended to match a larger unsigned type.
|
|
* @x: first value
|
|
* @y: second value
|
|
*/
|
|
#define umin(x, y) \
|
|
__careful_cmp((x) + 0u + 0ul + 0ull, (y) + 0u + 0ul + 0ull, <)
|
|
|
|
/**
|
|
* umax - return maximum of two non-negative values
|
|
* @x: first value
|
|
* @y: second value
|
|
*/
|
|
#define umax(x, y) \
|
|
__careful_cmp((x) + 0u + 0ul + 0ull, (y) + 0u + 0ul + 0ull, >)
|
|
|
|
/**
|
|
* min3 - return minimum of three values
|
|
* @x: first value
|
|
* @y: second value
|
|
* @z: third value
|
|
*/
|
|
#define min3(x, y, z) min((typeof(x))min(x, y), z)
|
|
|
|
/**
|
|
* max3 - return maximum of three values
|
|
* @x: first value
|
|
* @y: second value
|
|
* @z: third value
|
|
*/
|
|
#define max3(x, y, z) max((typeof(x))max(x, y), z)
|
|
|
|
/**
|
|
* min_not_zero - return the minimum that is _not_ zero, unless both are zero
|
|
* @x: value1
|
|
* @y: value2
|
|
*/
|
|
#define min_not_zero(x, y) ({ \
|
|
typeof(x) __x = (x); \
|
|
typeof(y) __y = (y); \
|
|
__x == 0 ? __y : ((__y == 0) ? __x : min(__x, __y)); })
|
|
|
|
/**
|
|
* clamp - return a value clamped to a given range with strict typechecking
|
|
* @val: current value
|
|
* @lo: lowest allowable value
|
|
* @hi: highest allowable value
|
|
*
|
|
* This macro does strict typechecking of @lo/@hi to make sure they are of the
|
|
* same type as @val. See the unnecessary pointer comparisons.
|
|
*/
|
|
#define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi)
|
|
|
|
/*
|
|
* ..and if you can't take the strict
|
|
* types, you can specify one yourself.
|
|
*
|
|
* Or not use min/max/clamp at all, of course.
|
|
*/
|
|
|
|
/**
|
|
* min_t - return minimum of two values, using the specified type
|
|
* @type: data type to use
|
|
* @x: first value
|
|
* @y: second value
|
|
*/
|
|
#define min_t(type, x, y) __careful_cmp((type)(x), (type)(y), <)
|
|
|
|
/**
|
|
* max_t - return maximum of two values, using the specified type
|
|
* @type: data type to use
|
|
* @x: first value
|
|
* @y: second value
|
|
*/
|
|
#define max_t(type, x, y) __careful_cmp((type)(x), (type)(y), >)
|
|
|
|
/**
|
|
* clamp_t - return a value clamped to a given range using a given type
|
|
* @type: the type of variable to use
|
|
* @val: current value
|
|
* @lo: minimum allowable value
|
|
* @hi: maximum allowable value
|
|
*
|
|
* This macro does no typechecking and uses temporary variables of type
|
|
* @type to make all the comparisons.
|
|
*/
|
|
#define clamp_t(type, val, lo, hi) min_t(type, max_t(type, val, lo), hi)
|
|
|
|
/**
|
|
* clamp_val - return a value clamped to a given range using val's type
|
|
* @val: current value
|
|
* @lo: minimum allowable value
|
|
* @hi: maximum allowable value
|
|
*
|
|
* This macro does no typechecking and uses temporary variables of whatever
|
|
* type the input argument @val is. This is useful when @val is an unsigned
|
|
* type and @lo and @hi are literals that will otherwise be assigned a signed
|
|
* integer type.
|
|
*/
|
|
#define clamp_val(val, lo, hi) clamp_t(typeof(val), val, lo, hi)
|
|
|
|
/**
|
|
* swap - swap values of @a and @b
|
|
* @a: first value
|
|
* @b: second value
|
|
*/
|
|
#define swap(a, b) \
|
|
do { typeof(a) __tmp = (a); (a) = (b); (b) = __tmp; } while (0)
|
|
|
|
#endif /* _LINUX_MINMAX_H */
|